JSON解析失败: ${e.message}
`);
return;
}
try {
// 获取Worker实例（异步）
let worker = await _getWorkerInstance();
if (worker) {
// 设置错误处理，如果Worker因为CSP等原因失败，回退到同步模式
let workerErrorHandler = function(e) {
// 静默处理，不输出日志
cspRestricted = true; // 标记为CSP受限，避免重复尝试
workerInstance = null;
formatSync(jsonStr, skin, escapeJsonString);
};
worker.onerror = workerErrorHandler;
// 设置超时，如果Worker长时间无响应，回退到同步模式
let workerTimeout = setTimeout(() => {
// 静默处理，不输出日志
if (workerInstance) {
try {
workerInstance.terminate();
} catch (e) {}
workerInstance = null;
}
formatSync(jsonStr, skin, escapeJsonString);
}, 5000);
// 设置消息处理程序
worker.onmessage = function (evt) {
clearTimeout(workerTimeout);
let msg = evt.data;
switch (msg[0]) {
case 'FORMATTING':
formattingMsg.show();
break;
case 'FORMATTED':
formattingMsg.hide();
jfContent.html(msg[1]);
_buildOptionBar();
// 事件绑定
_addEvents();
// 支持文件下载
_downloadSupport(cachedJsonString);
break;
}
};
// 发送格式化请求
try {
worker.postMessage({
jsonString: jsonStr,
skin: skin,
escapeJsonString: escapeJsonStringEnabled
});
} catch (e) {
// 如果发送消息失败（Worker可能已被CSP阻止），回退到同步模式
// 静默处理，不输出日志
cspRestricted = true; // 标记为CSP受限，避免重复尝试
clearTimeout(workerTimeout);
workerInstance = null;
formatSync(jsonStr, skin, escapeJsonString);
}
} else {
// Worker创建失败，回退到同步方式
formatSync(jsonStr, skin, escapeJsonString);
}
} catch (e) {
console.error('Worker处理失败:', e);
// 出现任何错误，回退到同步方式
formatSync(jsonStr, skin, escapeJsonString);
}
};
// 同步的方式格式化
let formatSync = function (jsonStr, skin, escapeJsonString) {
_initElements();
// 设置转义功能标志
if (escapeJsonString !== undefined) {
escapeJsonStringEnabled = escapeJsonString;
}
// 显示格式化进度
formattingMsg.show();
try {
// 先验证JSON是否有效（使用与worker一致的BigInt安全解析）
let parsedJson = _parseWithBigInt(jsonStr);
cachedJsonString = JSON.stringify(parsedJson, function(key, value) {
if (typeof value === 'bigint') {
return value.toString();
}
if (isBigNumberLike(value)) {
return getBigNumberDisplayString(value);
}
if (typeof value === 'number' && value.toString().includes('e')) {
return value.toLocaleString('fullwide', {useGrouping: false});
}
return value;
}, 4);
// 设置原始JSON内容到jfPre（用于元数据按钮）
jfPre.html(htmlspecialchars(cachedJsonString));
// 使用完整的JSON美化功能
let formattedHtml = formatJsonToHtml(parsedJson, skin);
// 创建正确的HTML结构：jfContent > formattedJson
let formattedJsonDiv = $('');
formattedJsonDiv.html(formattedHtml);
jfContent.html(formattedJsonDiv);
// 隐藏进度提示
formattingMsg.hide();
// 构建操作栏
_buildOptionBar();
// 事件绑定
_addEvents();
// 支持文件下载
_downloadSupport(cachedJsonString);
return;
} catch (e) {
console.error('JSON格式化失败:', e);
jfContent.html(`JSON格式化失败: ${e.message}
`);
// 隐藏进度提示
formattingMsg.hide();
}
};
// 与 worker 保持一致的 BigInt 安全解析：
// 1) 给可能的大整数加标记；2) 使用reviver还原为原生BigInt
let _parseWithBigInt = function(text) {
// 先解析JSON，然后在对象层面处理大整数
// 这样可以避免在字符串内容中错误地匹配数字
try {
// 直接解析，如果成功则不需要BigInt处理
return JSON.parse(text);
} catch (e) {
// 如果解析失败，可能是因为大整数导致的精度问题
// 使用更安全的方式：只在非字符串上下文中标记大整数
// 通过状态机跟踪是否在字符串内部
let inString = false;
let escape = false;
let marked = '';
for (let i = 0; i < text.length; i++) {
const char = text[i];
if (escape) {
marked += char;
escape = false;
continue;
}
if (char === '\\') {
marked += char;
escape = true;
continue;
}
if (char === '"') {
inString = !inString;
marked += char;
continue;
}
marked += char;
}
// 只在非字符串上下文中替换大整数
// 使用更精确的正则，确保不在字符串内
const result = text.replace(/([:,\[]\s*)(-?\d{16,})(\s*)(?=[,\]\}])/g, function(match, prefix, number, spaces, offset) {
// 检查这个位置是否在字符串内
let inStr = false;
let esc = false;
for (let i = 0; i < offset; i++) {
if (esc) {
esc = false;
continue;
}
if (text[i] === '\\') {
esc = true;
continue;
}
if (text[i] === '"') {
inStr = !inStr;
}
}
// 如果在字符串内，不替换
if (inStr) {
return match;
}
return prefix + '"__BigInt__' + number + '"' + spaces;
});
return JSON.parse(result, function(key, value) {
if (typeof value === 'string' && value.indexOf('__BigInt__') === 0) {
try {
return BigInt(value.slice(10));
} catch (e) {
return value.slice(10);
}
}
return value;
});
}
};
// 工具函数：获取或创建唯一图片预览浮窗节点
function getOrCreateImgPreview() {
let $img = $('#fh-img-preview');
if (!$img.length) {
$img = $('/, '').replace(/<\/div>$/, '');
// 返回格式化的JSON结构，但保持在外层的字符串容器中
// 使用block显示，确保完全展开
return '
' +
'"' +
'
';
}
} catch (e) {
// 解析失败，按普通字符串处理
}
}
}
return '' +
nestedHTML +
'
' +
'"' +
'' + formatStringValue(JSON.stringify(this.value)) + '
';
}
case 'number':
// 确保大数字不使用科学计数法
let numStr = typeof this.value === 'number' && this.value.toString().includes('e')
? this.value.toLocaleString('fullwide', {useGrouping: false})
: this.value;
return '' +
numStr +
'
';
case 'bigint':
// 对BigInt类型特殊处理，只显示数字，不添加n后缀
return '' +
getBigNumberDisplayString(this.value) +
'
';
case 'boolean':
return '' +
this.value +
'
';
case 'null':
return 'null
';
case 'object':
return this.getObjectHTML();
case 'array':
return this.getArrayHTML();
default:
return '';
}
},
getObjectHTML: function() {
if (!this.value || Object.keys(this.value).length === 0) {
return '{}
';
}
let html = '' +
'' +
'{' +
'' +
'
';
let keys = Object.keys(this.value);
keys.forEach((key, index) => {
let prop = this.value[key];
let childNode = createNode(prop);
// 判断子节点是否为对象或数组，决定是否加item-block
let itemClass = (childNode.type === 'object' || childNode.type === 'array') ? 'item item-block' : 'item';
html += '
';
return html;
},
getArrayHTML: function() {
if (!this.value || this.value.length === 0) {
return '';
// 如果值是对象或数组，在key前面添加展开按钮
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
}
html += '"' +
'' + htmlspecialchars(key) + '' +
'"' +
': ';
// 添加值
if (childNode.type === 'object' || childNode.type === 'array') {
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
}/, '').replace(/<\/div>$/, '');
}
// 如果不是最后一个属性，添加逗号
if (index < keys.length - 1) {
html += ',';
}
html += '
';
});
html += '[]
';
}
let html = '' +
'' +
'[' +
'' +
'
';
this.value.forEach((item, index) => {
let childNode = createNode(item);
html += '
';
return html;
},
// 新增内联HTML方法，用于在同一行显示开始大括号/方括号
getInlineHTML: function() {
switch(this.type) {
case 'object':
return this.getInlineObjectHTML();
case 'array':
return this.getInlineArrayHTML();
default:
return this.getHTML();
}
},
// 新增不包含展开按钮的内联HTML方法
getInlineHTMLWithoutExpand: function() {
switch(this.type) {
case 'object':
return this.getInlineObjectHTMLWithoutExpand();
case 'array':
return this.getInlineArrayHTMLWithoutExpand();
default:
return this.getHTML();
}
},
getInlineObjectHTML: function() {
if (!this.value || Object.keys(this.value).length === 0) {
return '{}';
}
let html = '{' +
'' +
'' +
'';
// 如果数组元素是对象或数组，在前面添加展开按钮
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
]/, '').replace(/<\/div>$/, '');
}
// 如果不是最后一个元素，添加逗号
if (index < this.value.length - 1) {
html += ',';
}
html += '
';
});
html += '';
let keys = Object.keys(this.value);
keys.forEach((key, index) => {
let prop = this.value[key];
let childNode = createNode(prop);
// 判断子节点是否为对象或数组，决定是否加item-block
let itemClass = (childNode.type === 'object' || childNode.type === 'array') ? 'item item-block' : 'item';
html += '
';
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
}
html += '"' +
'' + htmlspecialchars(key) + '' +
'"' +
': ';
if (childNode.type === 'object' || childNode.type === 'array') {
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
}';
return html;
},
getInlineArrayHTML: function() {
if (!this.value || this.value.length === 0) {
return '[]';
}
let html = '[' +
'' +
'' +
'/, '').replace(/<\/div>$/, '');
}
if (index < keys.length - 1) {
html += ',';
}
html += '
';
});
html += '';
this.value.forEach((item, index) => {
let childNode = createNode(item);
html += '
';
// 如果数组元素是对象或数组，在前面添加展开按钮
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
]';
return html;
},
getInlineObjectHTMLWithoutExpand: function() {
if (!this.value || Object.keys(this.value).length === 0) {
return '{}';
}
let html = '{' +
'' +
'/, '').replace(/<\/div>$/, '');
}
// 如果不是最后一个元素，添加逗号
if (index < this.value.length - 1) {
html += ',';
}
html += '
';
});
html += '';
let keys = Object.keys(this.value);
keys.forEach((key, index) => {
let prop = this.value[key];
let childNode = createNode(prop);
// 判断子节点是否为对象或数组，决定是否加item-block
let itemClass = (childNode.type === 'object' || childNode.type === 'array') ? 'item item-block' : 'item';
html += '
';
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
}
html += '"' +
'' + htmlspecialchars(key) + '' +
'"' +
': ';
if (childNode.type === 'object' || childNode.type === 'array') {
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
}';
return html;
},
getInlineArrayHTMLWithoutExpand: function() {
if (!this.value || this.value.length === 0) {
return '[]';
}
let html = '[' +
'' +
'/, '').replace(/<\/div>$/, '');
}
if (index < keys.length - 1) {
html += ',';
}
html += '
';
});
html += '';
this.value.forEach((item, index) => {
let childNode = createNode(item);
html += '
';
// 确保所有类型的数组元素都能正确处理
if (childNode.type === 'object' || childNode.type === 'array') {
html += '';
html += childNode.getInlineHTMLWithoutExpand();
} else {
html += childNode.getHTML().replace(/^
]';
return html;
}
};
return node;
}
// 获取值的类型
function getType(value) {
if (value === null) return 'null';
if (typeof value === 'bigint') return 'bigint';
if (typeof value === 'object') {
if (isBigNumberLike(value)) {
return 'bigint'; // 将 BigNumber 对象也当作 bigint 处理
}
if (Array.isArray(value)) return 'array';
return 'object';
}
return typeof value;
}
// 判断是否为URL
function isUrl(str) {
if (typeof str !== 'string') return false;
const urlRegex = /^(https?:\/\/|ftp:\/\/)[^\s<>"'\\]+$/i;
return urlRegex.test(str);
}
// 格式化字符串值，如果是URL则转换为链接
function formatStringValue(str) {
// URL正则表达式，匹配 http/https/ftp 协议的URL
const urlRegex = /^(https?:\/\/|ftp:\/\/)[^\s<>"'\\]+$/i;
if (urlRegex.test(str)) {
// 如果是URL，转换为链接
const escapedUrl = htmlspecialchars(str);
return '' + htmlspecialchars(str) + '';
} else {
// 直接显示解析后的字符串内容，不需要重新转义
// 这样可以保持用户原始输入的意图
return htmlspecialchars(str);
}
}
function isBigNumberLike(value) {
return value && typeof value === 'object' &&
typeof value.s === 'number' &&
typeof value.e === 'number' &&
Array.isArray(value.c);
}
function getBigNumberDisplayString(value) {
if (typeof value === 'bigint') {
return value.toString();
}
if (!isBigNumberLike(value)) {
return String(value);
}
const direct = tryConvertBigNumberToString(value);
if (direct) {
return direct;
}
return rebuildBigNumberFromParts(value);
}
function tryConvertBigNumberToString(value) {
const nativeToString = value && value.toString;
if (typeof nativeToString === 'function' && nativeToString !== Object.prototype.toString) {
try {
const result = nativeToString.call(value);
if (typeof result === 'string' && result !== '[object Object]') {
return result;
}
} catch (e) {}
}
const ctor = getAvailableBigNumberCtor();
if (ctor && typeof Object.setPrototypeOf === 'function') {
try {
if (!(value instanceof ctor)) {
Object.setPrototypeOf(value, ctor.prototype);
}
if (typeof value.toString === 'function' && value.toString !== Object.prototype.toString) {
const result = value.toString();
if (typeof result === 'string' && result !== '[object Object]') {
return result;
}
}
} catch (e) {}
}
return null;
}
function rebuildBigNumberFromParts(value) {
const sign = value.s < 0 ? '-' : '';
const CHUNK_SIZE = 14;
let digits = '';
for (let i = 0; i < value.c.length; i++) {
let chunkStr = Math.abs(value.c[i]).toString();
if (i > 0) {
chunkStr = chunkStr.padStart(CHUNK_SIZE, '0');
}
digits += chunkStr;
}
digits = digits.replace(/^0+/, '') || '0';
const decimalIndex = value.e + 1;
if (decimalIndex <= 0) {
const zeros = '0'.repeat(Math.abs(decimalIndex));
let fraction = zeros + digits;
fraction = fraction.replace(/0+$/, '');
if (!fraction) {
return sign + '0';
}
return sign + '0.' + fraction;
}
if (decimalIndex >= digits.length) {
return sign + digits + '0'.repeat(decimalIndex - digits.length);
}
const intPart = digits.slice(0, decimalIndex);
let fracPart = digits.slice(decimalIndex).replace(/0+$/, '');
if (!fracPart) {
return sign + intPart;
}
return sign + intPart + '.' + fracPart;
}
function getAvailableBigNumberCtor() {
if (typeof JSON !== 'undefined' && typeof JSON.BigNumber === 'function') {
return JSON.BigNumber;
}
if (typeof BigNumber === 'function') {
return BigNumber;
}
return null;
}
return {
format: format,
formatSync: formatSync,
setEscapeEnabled: function(enabled) {
escapeJsonStringEnabled = enabled;
}
}
})();
/, '').replace(/<\/div>$/, '');
}
// 如果不是最后一个元素，添加逗号
if (index < this.value.length - 1) {
html += ',';
}
html += '
';
});
html += '