1089 lines
40 KiB
JavaScript
1089 lines
40 KiB
JavaScript
// Module ID: 552
|
|
// Function ID: 6669
|
|
// Name: addNumericSeparator
|
|
// Dependencies: [553]
|
|
|
|
// Module 552 (addNumericSeparator)
|
|
function addNumericSeparator(name, typeError1) {
|
|
if (name !== Infinity) {
|
|
if (name !== -Infinity) {
|
|
if (name == name) {
|
|
if (!test.call(/e/, typeError1)) {
|
|
const tmp2 = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
|
if ("number" === typeof name) {
|
|
if (name < 0) {
|
|
let tmp4 = -floor(-name);
|
|
} else {
|
|
tmp4 = floor(name);
|
|
}
|
|
if (tmp4 !== name) {
|
|
const _String = String;
|
|
const StringResult = String(tmp4);
|
|
const text = `${replace.call(arr, tmp2, "$&_")}.`;
|
|
return `${replace.call(arr, tmp2, "$&_")}.` + replace.call(replace.call(slice.call(typeError1, String(tmp4).length + 1), /([0-9]{3})/g, "$&_"), /_$/, "");
|
|
}
|
|
}
|
|
return replace.call(typeError1, tmp2, "$&_");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return typeError1;
|
|
}
|
|
function wrapQuotes(replace, double, quoteStyle) {
|
|
return obj[quoteStyle.quoteStyle || double] + replace + obj[quoteStyle.quoteStyle || double];
|
|
}
|
|
function quote(value) {
|
|
return replace.call(String(value), /"/g, """);
|
|
}
|
|
function canTrustToString(name) {
|
|
let tmp = !toStringTag;
|
|
if (!tmp) {
|
|
let tmp2 = "object" === typeof name;
|
|
if (tmp2) {
|
|
let tmp4 = toStringTag in name;
|
|
if (!tmp4) {
|
|
tmp4 = undefined !== name[toStringTag];
|
|
}
|
|
tmp2 = tmp4;
|
|
}
|
|
tmp = !tmp2;
|
|
}
|
|
return tmp;
|
|
}
|
|
function isArray(name) {
|
|
let tmp = "[object Array]" === toStr(name);
|
|
if (tmp) {
|
|
tmp = canTrustToString(name);
|
|
}
|
|
return tmp;
|
|
}
|
|
function isRegExp(name) {
|
|
let tmp = "[object RegExp]" === toStr(name);
|
|
if (tmp) {
|
|
tmp = canTrustToString(name);
|
|
}
|
|
return tmp;
|
|
}
|
|
function isSymbol(custom) {
|
|
let tmp = custom;
|
|
if (closure_26) {
|
|
if (tmp) {
|
|
tmp = "object" === typeof custom;
|
|
}
|
|
if (tmp) {
|
|
const _Symbol = Symbol;
|
|
tmp = custom instanceof Symbol;
|
|
}
|
|
return tmp;
|
|
} else if ("symbol" === typeof tmp) {
|
|
return true;
|
|
} else {
|
|
if (custom) {
|
|
if ("object" === typeof custom) {
|
|
if (toString) {
|
|
toString.call(custom);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function has(arg0, arg1) {
|
|
return callback.call(arg0, arg1);
|
|
}
|
|
function toStr(name) {
|
|
return toString.call(name);
|
|
}
|
|
function indexOf(arr) {
|
|
if (arr.indexOf) {
|
|
return arr.indexOf(arg1);
|
|
} else {
|
|
let num = 0;
|
|
if (0 < arr.length) {
|
|
while (arr[num] !== arg1) {
|
|
num = num + 1;
|
|
}
|
|
return num;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
function inspectString(slice, maxStringLength) {
|
|
if (slice.length > maxStringLength.maxStringLength) {
|
|
const diff = slice.length - maxStringLength.maxStringLength;
|
|
let str4 = "";
|
|
if (diff > 1) {
|
|
str4 = "s";
|
|
}
|
|
return inspectString(slice.call(slice, 0, maxStringLength.maxStringLength), maxStringLength) + ("... " + diff + " more character" + str4);
|
|
} else {
|
|
let str = maxStringLength.quoteStyle;
|
|
if (!str) {
|
|
str = "single";
|
|
}
|
|
obj[str].lastIndex = 0;
|
|
return wrapQuotes(replace.call(replace.call(slice, obj[str], "\\$1"), /[\x00-\x1f]/g, lowbyte), "single", maxStringLength);
|
|
}
|
|
}
|
|
function lowbyte(str) {
|
|
str = str.charCodeAt(0);
|
|
const tmp = { 8: "b", 9: "t", 10: "n", 12: "f", 13: "r" }[str];
|
|
if (tmp) {
|
|
let text = `\\${tmp}`;
|
|
} else {
|
|
let str2 = "";
|
|
if (str < 16) {
|
|
str2 = "0";
|
|
}
|
|
text = `\\x${str2}${tmp3(str.toString(16))}`;
|
|
}
|
|
return text;
|
|
}
|
|
function markBoxed(typeError1) {
|
|
return "Object(" + typeError1 + ")";
|
|
}
|
|
function weakCollectionOf(WeakMap) {
|
|
return WeakMap + " { ? }";
|
|
}
|
|
function collectionOf(Map, items1, items, prev) {
|
|
const text = `${Map} (${items1}`;
|
|
if (prev) {
|
|
let callResult = indentedJoin(items, prev);
|
|
} else {
|
|
callResult = join.call(items, ", ");
|
|
}
|
|
return text + ") {" + callResult + "}";
|
|
}
|
|
function indentedJoin(arr2, prev) {
|
|
if (0 === arr2.length) {
|
|
return "";
|
|
} else {
|
|
const text = `
|
|
${prev.prev}${prev.base}`;
|
|
return text + join.call(arr2, "," + text) + "\n" + prev.prev;
|
|
}
|
|
}
|
|
function arrObjKeys(name, inspect) {
|
|
let length;
|
|
const tmp = isArray(name);
|
|
const items = [];
|
|
if (tmp) {
|
|
items.length = name.length;
|
|
for (let num = 0; num < name.length; num = num + 1) {
|
|
let tmp2 = has;
|
|
let tmp3 = num;
|
|
let str2 = "";
|
|
if (has(name, num)) {
|
|
str2 = inspect(name[num], name);
|
|
}
|
|
items[num] = str2;
|
|
}
|
|
}
|
|
if ("function" === typeof getOwnPropertySymbols) {
|
|
let items1 = getOwnPropertySymbols(name);
|
|
} else {
|
|
items1 = [];
|
|
}
|
|
if (closure_26) {
|
|
const obj = {};
|
|
let num2 = 0;
|
|
let tmp5 = obj;
|
|
if (0 < items1.length) {
|
|
do {
|
|
obj["$" + items1[num2]] = items1[num2];
|
|
num2 = num2 + 1;
|
|
tmp5 = obj;
|
|
length = items1.length;
|
|
} while (num2 < length);
|
|
}
|
|
}
|
|
for (const key10038 in arg0) {
|
|
let tmp16 = key10038;
|
|
let tmp17 = has;
|
|
if (!has(arg0, key10038)) {
|
|
continue;
|
|
} else {
|
|
let tmp6 = tmp;
|
|
if (tmp) {
|
|
let _String = String;
|
|
let _Number = Number;
|
|
tmp6 = String(Number(key10038)) === key10038;
|
|
}
|
|
if (tmp6) {
|
|
tmp6 = key10038 < arg0.length;
|
|
}
|
|
if (!tmp6) {
|
|
let tmp7 = closure_26;
|
|
if (closure_26) {
|
|
let _Symbol = Symbol;
|
|
tmp7 = tmp5["$" + key10038] instanceof Symbol;
|
|
}
|
|
tmp6 = tmp7;
|
|
}
|
|
if (tmp6) {
|
|
continue;
|
|
} else {
|
|
let tmp8 = test;
|
|
let push = items.push;
|
|
if (test.call(/[^\w$]/, key10038)) {
|
|
let text = `${arg1(key10038, arg0)}: `;
|
|
let arr = push(`${arg1(key10038, arg0)}: ` + arg1(arg0[key10038], arg0));
|
|
continue;
|
|
} else {
|
|
let text1 = `${key10038}: `;
|
|
arr = push(`${key10038}: ` + arg1(arg0[key10038], arg0));
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
if ("function" === typeof getOwnPropertySymbols) {
|
|
for (let num3 = 0; num3 < items1.length; num3 = num3 + 1) {
|
|
let tmp13 = propertyIsEnumerable;
|
|
if (propertyIsEnumerable.call(name, items1[num3])) {
|
|
let text2 = `[${inspect(arr2[num3])}`;
|
|
let arr1 = items.push(`${`[${inspect(arr2[num3])}`}]: ${inspect(name[arr2[num3]], name)}`);
|
|
}
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
let forEach = "function" === typeof Map;
|
|
if (forEach) {
|
|
let _Map = Map;
|
|
forEach = Map.prototype;
|
|
}
|
|
let ownPropertyDescriptor = null;
|
|
if (Object.getOwnPropertyDescriptor) {
|
|
ownPropertyDescriptor = null;
|
|
if (forEach) {
|
|
let _Object = Object;
|
|
const _Map2 = Map;
|
|
ownPropertyDescriptor = Object.getOwnPropertyDescriptor(Map.prototype, "size");
|
|
}
|
|
}
|
|
let get = null;
|
|
if (forEach) {
|
|
get = null;
|
|
if (ownPropertyDescriptor) {
|
|
get = null;
|
|
if ("function" === typeof ownPropertyDescriptor.get) {
|
|
get = ownPropertyDescriptor.get;
|
|
}
|
|
}
|
|
}
|
|
if (forEach) {
|
|
const _Map3 = Map;
|
|
forEach = Map.prototype.forEach;
|
|
}
|
|
let forEach2 = "function" === typeof Set;
|
|
if (forEach2) {
|
|
let _Set = Set;
|
|
forEach2 = Set.prototype;
|
|
}
|
|
let ownPropertyDescriptor1 = null;
|
|
if (Object.getOwnPropertyDescriptor) {
|
|
ownPropertyDescriptor1 = null;
|
|
if (forEach2) {
|
|
let _Object2 = Object;
|
|
const _Set2 = Set;
|
|
ownPropertyDescriptor1 = Object.getOwnPropertyDescriptor(Set.prototype, "size");
|
|
}
|
|
}
|
|
let get1 = null;
|
|
if (forEach2) {
|
|
get1 = null;
|
|
if (ownPropertyDescriptor1) {
|
|
get1 = null;
|
|
if ("function" === typeof ownPropertyDescriptor1.get) {
|
|
get1 = ownPropertyDescriptor1.get;
|
|
}
|
|
}
|
|
}
|
|
if (forEach2) {
|
|
const _Set3 = Set;
|
|
forEach2 = Set.prototype.forEach;
|
|
}
|
|
has = null;
|
|
if ("function" === typeof WeakMap) {
|
|
let _WeakMap = WeakMap;
|
|
has = null;
|
|
if (WeakMap.prototype) {
|
|
const _WeakMap2 = WeakMap;
|
|
has = WeakMap.prototype.has;
|
|
}
|
|
}
|
|
let has1 = null;
|
|
if ("function" === typeof WeakSet) {
|
|
let _WeakSet = WeakSet;
|
|
has1 = null;
|
|
if (WeakSet.prototype) {
|
|
const _WeakSet2 = WeakSet;
|
|
has1 = WeakSet.prototype.has;
|
|
}
|
|
}
|
|
let deref = null;
|
|
if ("function" === typeof WeakRef) {
|
|
const _WeakRef = WeakRef;
|
|
deref = null;
|
|
if (WeakRef.prototype) {
|
|
const _WeakRef2 = WeakRef;
|
|
deref = WeakRef.prototype.deref;
|
|
}
|
|
}
|
|
toString = Function.prototype.toString;
|
|
slice = Array.prototype.slice;
|
|
valueOf = null;
|
|
if ("function" === typeof BigInt) {
|
|
const _BigInt = BigInt;
|
|
valueOf = BigInt.prototype.valueOf;
|
|
}
|
|
toString = null;
|
|
if ("function" === typeof Symbol) {
|
|
let _Symbol = Symbol;
|
|
toString = null;
|
|
if ("symbol" === typeof Symbol.iterator) {
|
|
const _Symbol2 = Symbol;
|
|
toString = Symbol.prototype.toString;
|
|
}
|
|
}
|
|
let tmp10 = "function" === typeof Symbol;
|
|
if (tmp10) {
|
|
const _Symbol3 = Symbol;
|
|
tmp10 = "object" === typeof Symbol.iterator;
|
|
}
|
|
let closure_26 = tmp10;
|
|
let toStringTag = null;
|
|
if ("function" === typeof Symbol) {
|
|
const _Symbol4 = Symbol;
|
|
toStringTag = null;
|
|
if (Symbol.toStringTag) {
|
|
const _Symbol5 = Symbol;
|
|
toStringTag = Symbol.toStringTag;
|
|
const _Symbol6 = Symbol;
|
|
toStringTag = Symbol.toStringTag;
|
|
}
|
|
}
|
|
if ("function" === typeof Reflect) {
|
|
const _Reflect = Reflect;
|
|
} else {
|
|
let _Object3 = Object;
|
|
getPrototypeOf = Object.getPrototypeOf;
|
|
}
|
|
if (!getPrototypeOf) {
|
|
let _Array = Array;
|
|
let fn = null;
|
|
if ([].__proto__ === Array.prototype) {
|
|
fn = (arg0) => arg0.__proto__;
|
|
}
|
|
getPrototypeOf = fn;
|
|
}
|
|
let custom = null;
|
|
if (isSymbol(require("module_553").custom)) {
|
|
custom = require("module_553").custom;
|
|
}
|
|
let obj = Object.create(null);
|
|
obj.double = "\"";
|
|
obj.single = "'";
|
|
obj = Object.create(null);
|
|
obj.double = /(["\\])/g;
|
|
obj.single = /(['\\])/g;
|
|
function inspect_(name, quoteStyle) {
|
|
let items1;
|
|
let length;
|
|
let obj = quoteStyle;
|
|
let num = arg2;
|
|
let closure_0 = name;
|
|
let _require = arg2;
|
|
let dependencyMap = arg3;
|
|
function inspect(cause) {
|
|
if (arg1) {
|
|
const callResult = outer1_21.call(closure_2);
|
|
closure_2 = callResult;
|
|
callResult.push(arg1);
|
|
}
|
|
if (arg2) {
|
|
const obj = {};
|
|
obj.depth = obj.depth;
|
|
if (outer1_41(obj, "quoteStyle")) {
|
|
obj.quoteStyle = obj.quoteStyle;
|
|
}
|
|
return outer1_51(cause, obj, c1 + 1, closure_2);
|
|
} else {
|
|
return outer1_51(cause, obj, c1 + 1, closure_2);
|
|
}
|
|
}
|
|
if (!quoteStyle) {
|
|
obj = {};
|
|
}
|
|
if (has(obj, "quoteStyle")) {
|
|
let typeError1 = has;
|
|
if (!has(obj, obj.quoteStyle)) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("option \"quoteStyle\" must be \"single\" or \"double\"");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (has(obj, "maxStringLength")) {
|
|
if ("number" === typeof obj.maxStringLength) {
|
|
let tmp10 = obj.maxStringLength < 0;
|
|
if (tmp10) {
|
|
tmp10 = obj.maxStringLength !== Infinity;
|
|
}
|
|
let tmp9 = tmp10;
|
|
} else {
|
|
tmp9 = null !== obj.maxStringLength;
|
|
}
|
|
if (tmp9) {
|
|
typeError1 = globalThis;
|
|
const _TypeError5 = TypeError;
|
|
typeError1 = new.target;
|
|
typeError1 = new.target;
|
|
typeError1 = new TypeError("option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`");
|
|
throw typeError1;
|
|
}
|
|
}
|
|
const tmp11 = !has(obj, "customInspect") || obj.customInspect;
|
|
if ("boolean" !== typeof tmp11) {
|
|
if ("symbol" !== tmp11) {
|
|
typeError1 = globalThis;
|
|
const _TypeError4 = TypeError;
|
|
typeError1 = new.target;
|
|
typeError1 = new.target;
|
|
typeError1 = new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
|
|
throw typeError1;
|
|
}
|
|
}
|
|
if (has(obj, "indent")) {
|
|
if (null !== obj.indent) {
|
|
if ("\t" !== obj.indent) {
|
|
const _parseInt = parseInt;
|
|
const _TypeError2 = TypeError;
|
|
const typeError2 = new TypeError("option \"indent\" must be \"\\t\", an integer > 0, or `null`");
|
|
throw typeError2;
|
|
}
|
|
}
|
|
}
|
|
if (has(obj, "numericSeparator")) {
|
|
if ("boolean" !== typeof obj.numericSeparator) {
|
|
typeError1 = globalThis;
|
|
const _TypeError3 = TypeError;
|
|
typeError1 = new.target;
|
|
typeError1 = new.target;
|
|
typeError1 = new TypeError("option \"numericSeparator\", if provided, must be `true` or `false`");
|
|
throw typeError1;
|
|
}
|
|
}
|
|
const numericSeparator = obj.numericSeparator;
|
|
if (undefined === name) {
|
|
return "undefined";
|
|
} else {
|
|
typeError1 = null;
|
|
if (null === name) {
|
|
return "null";
|
|
} else {
|
|
typeError1 = typeof name;
|
|
if ("boolean" === typeError1) {
|
|
let str80 = "false";
|
|
if (name) {
|
|
str80 = "true";
|
|
}
|
|
return str80;
|
|
} else if ("string" === typeError1) {
|
|
typeError1 = inspectString;
|
|
return inspectString(name, obj);
|
|
} else if ("number" === typeError1) {
|
|
if (0 === name) {
|
|
let str79 = "-0";
|
|
if (Infinity / name > 0) {
|
|
str79 = "0";
|
|
}
|
|
return str79;
|
|
} else {
|
|
typeError1 = globalThis;
|
|
const _String9 = String;
|
|
typeError1 = String(name);
|
|
if (numericSeparator) {
|
|
typeError1 = addNumericSeparator;
|
|
typeError1 = addNumericSeparator(name, typeError1);
|
|
}
|
|
return typeError1;
|
|
}
|
|
} else if ("bigint" === typeError1) {
|
|
typeError1 = globalThis;
|
|
const _String8 = String;
|
|
typeError1 = `${String(name)}n`;
|
|
if (numericSeparator) {
|
|
typeError1 = addNumericSeparator;
|
|
typeError1 = addNumericSeparator(name, `${String(name)}n`);
|
|
}
|
|
return typeError1;
|
|
} else {
|
|
let num6 = 5;
|
|
if (undefined !== obj.depth) {
|
|
num6 = obj.depth;
|
|
}
|
|
if (undefined === num) {
|
|
_require = 0;
|
|
num = 0;
|
|
}
|
|
if (num >= num6) {
|
|
if (num6 > 0) {
|
|
if ("object" === typeError1) {
|
|
typeError1 = isArray;
|
|
let str77 = "[Object]";
|
|
if (isArray(name)) {
|
|
str77 = "[Array]";
|
|
}
|
|
return str77;
|
|
}
|
|
}
|
|
}
|
|
let str7 = "\t";
|
|
if ("\t" === obj.indent) {
|
|
obj = { base: str7 };
|
|
const _Array2 = Array;
|
|
obj.prev = join.call(Array(num + 1), ` `);
|
|
let tmp18 = obj;
|
|
} else {
|
|
tmp18 = null;
|
|
if ("number" === typeof obj.indent) {
|
|
tmp18 = null;
|
|
if (obj.indent > 0) {
|
|
const _Array = Array;
|
|
str7 = join.call(Array(obj.indent + 1), " ");
|
|
}
|
|
}
|
|
}
|
|
if (undefined === dependencyMap) {
|
|
dependencyMap = [];
|
|
} else if (indexOf(dependencyMap, name) >= 0) {
|
|
return "[Circular]";
|
|
}
|
|
if ("function" === typeError1) {
|
|
typeError1 = isRegExp;
|
|
if (!isRegExp(name)) {
|
|
if (name.name) {
|
|
name = name.name;
|
|
} else {
|
|
let callResult = match.call(toString.call(name), /^function\s*([\w$]+)/);
|
|
name = null;
|
|
if (callResult) {
|
|
name = callResult[1];
|
|
}
|
|
}
|
|
const arr = arrObjKeys(name, inspect);
|
|
let str11 = " (anonymous)";
|
|
if (name) {
|
|
str11 = `: ${tmp29}`;
|
|
}
|
|
let str13 = "";
|
|
if (arr.length > 0) {
|
|
str13 = `${" { " + join.call(arr, ", ")} }`;
|
|
}
|
|
return "[Function" + str11 + "]" + str13;
|
|
}
|
|
}
|
|
if (isSymbol(name)) {
|
|
typeError1 = closure_26;
|
|
if (closure_26) {
|
|
typeError1 = replace;
|
|
typeError1 = globalThis;
|
|
const _String7 = String;
|
|
typeError1 = replace.call(String(name), /^(Symbol\(.*\))_[^)]*$/, "$1");
|
|
} else {
|
|
typeError1 = toString;
|
|
typeError1 = toString.call(name);
|
|
}
|
|
if ("object" === typeError1) {
|
|
typeError1 = closure_26;
|
|
if (!closure_26) {
|
|
typeError1 = markBoxed;
|
|
typeError1 = markBoxed(typeError1);
|
|
}
|
|
}
|
|
return typeError1;
|
|
} else {
|
|
let flag = false;
|
|
if (name) {
|
|
flag = false;
|
|
if ("object" === typeError1) {
|
|
if ("undefined" === typeof globalThis.HTMLElement) {
|
|
flag = "string" === typeof name.nodeName && "function" === typeof name.getAttribute;
|
|
const tmp34 = "string" === typeof name.nodeName && "function" === typeof name.getAttribute;
|
|
} else {
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
if (flag) {
|
|
typeError1 = toLowerCase;
|
|
typeError1 = globalThis;
|
|
const _String5 = String;
|
|
typeError1 = `<${tmp(String(name.nodeName))}`;
|
|
const arr8 = name.attributes || [];
|
|
let num22 = 0;
|
|
if (0 < arr8.length) {
|
|
do {
|
|
typeError1 = wrapQuotes;
|
|
typeError1 = quote;
|
|
typeError1 = ` ${arr8[num22].name}`;
|
|
typeError1 = typeError1 + (` ${arr8[num22].name}` + "=" + wrapQuotes(quote(arr8[num22].value), "double", obj));
|
|
num22 = num22 + 1;
|
|
length = arr8.length;
|
|
} while (num22 < length);
|
|
}
|
|
typeError1 = `${tmp}>`;
|
|
typeError1 = name.childNodes && name.childNodes.length;
|
|
if (typeError1) {
|
|
typeError1 = `${tmp}...`;
|
|
}
|
|
typeError1 = toLowerCase;
|
|
const _String6 = String;
|
|
return typeError1 + ("</" + toLowerCase.call(String(name.nodeName)) + ">");
|
|
} else if (isArray(name)) {
|
|
if (0 === name.length) {
|
|
return "[]";
|
|
} else {
|
|
typeError1 = arrObjKeys;
|
|
const arr9 = arrObjKeys(name, inspect);
|
|
if (tmp18) {
|
|
let num21 = 0;
|
|
let flag8 = true;
|
|
if (0 < arr9.length) {
|
|
typeError1 = indexOf;
|
|
flag8 = false;
|
|
while (indexOf(arr9[num21], "\n") < 0) {
|
|
num21 = num21 + 1;
|
|
flag8 = true;
|
|
if (num21 >= arr9.length) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!flag8) {
|
|
typeError1 = indentedJoin;
|
|
typeError1 = `${"[" + indentedJoin(arr9, tmp18)}]`;
|
|
}
|
|
return typeError1;
|
|
}
|
|
typeError1 = join;
|
|
typeError1 = `${"[ " + join.call(arr9, ", ")} ]`;
|
|
}
|
|
} else {
|
|
let tmp37 = "[object Error]" === toStr(name);
|
|
if (tmp37) {
|
|
tmp37 = canTrustToString(name);
|
|
}
|
|
if (tmp37) {
|
|
typeError1 = arrObjKeys;
|
|
const arr7 = arrObjKeys(name, inspect);
|
|
let str49 = globalThis;
|
|
const _Error = Error;
|
|
if (!("cause" in Error.prototype)) {
|
|
if ("cause" in name) {
|
|
typeError1 = propertyIsEnumerable;
|
|
if (!propertyIsEnumerable.call(name, "cause")) {
|
|
const _String3 = String;
|
|
typeError1 = join;
|
|
typeError1 = concat;
|
|
typeError1 = `{ [${String(name)}`;
|
|
return `{ [${String(name)}` + "] " + join.call(concat.call("[cause]: " + inspect(name.cause), arr7), ", ") + " }";
|
|
}
|
|
}
|
|
}
|
|
if (0 === arr7.length) {
|
|
typeError1 = `[${str49.String(name)}`;
|
|
str49 = "]";
|
|
typeError1 = `[${str49.String(name)}]`;
|
|
} else {
|
|
const _String4 = String;
|
|
typeError1 = join;
|
|
typeError1 = `{ [${String(name)}`;
|
|
typeError1 = `${`{ [${String(name)}` + "] " + join.call(arr7, ", ")} }`;
|
|
}
|
|
} else {
|
|
if ("object" === typeError1) {
|
|
if (tmp11) {
|
|
if (custom) {
|
|
if ("function" === typeof name[custom]) {
|
|
if (_require(553)) {
|
|
typeError1 = _require;
|
|
typeError1 = dependencyMap;
|
|
obj = { depth: num6 - num };
|
|
return _require(553)(name, obj);
|
|
}
|
|
}
|
|
}
|
|
if ("symbol" !== tmp11) {
|
|
if ("function" === typeof name.inspect) {
|
|
return name.inspect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let flag2 = false;
|
|
if (obj) {
|
|
flag2 = false;
|
|
if (tmp43) {
|
|
flag2 = false;
|
|
if ("object" === typeof tmp43) {
|
|
obj.call(tmp43);
|
|
items1.call(tmp43);
|
|
const _Map = Map;
|
|
flag2 = tmp43 instanceof Map;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag2) {
|
|
let items = [];
|
|
typeError1 = items;
|
|
if (items) {
|
|
typeError1 = items;
|
|
typeError1 = items.call(name, (arg0, arg1) => {
|
|
const text = `${inspect(arg1, closure_0, true)} => `;
|
|
items.push(`${inspect(arg1, closure_0, true)} => ` + inspect(arg0, closure_0));
|
|
});
|
|
}
|
|
typeError1 = collectionOf;
|
|
typeError1 = obj;
|
|
let str48 = "Map";
|
|
typeError1 = items;
|
|
typeError1 = tmp18;
|
|
return collectionOf("Map", obj.call(name), items, tmp18);
|
|
} else {
|
|
let tmp55 = name;
|
|
let tmp56 = items1;
|
|
let flag3 = false;
|
|
if (items1) {
|
|
let tmp57 = name;
|
|
flag3 = false;
|
|
if (tmp55) {
|
|
let tmp58 = name;
|
|
flag3 = false;
|
|
if ("object" === typeof tmp55) {
|
|
let tmp59 = items1;
|
|
let tmp60 = name;
|
|
let callResult3 = items1.call(tmp55);
|
|
let tmp62 = obj;
|
|
let tmp63 = name;
|
|
let callResult4 = obj.call(tmp55);
|
|
let tmp65 = name;
|
|
let tmp66 = globalThis;
|
|
let _Set = Set;
|
|
flag3 = tmp55 instanceof Set;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag3) {
|
|
items1 = [];
|
|
typeError1 = inspect;
|
|
if (inspect) {
|
|
typeError1 = inspect;
|
|
typeError1 = inspect.call(name, (arg0) => {
|
|
items1.push(inspect(arg0, closure_0));
|
|
});
|
|
}
|
|
typeError1 = collectionOf;
|
|
typeError1 = items1;
|
|
let str47 = "Set";
|
|
typeError1 = items1;
|
|
typeError1 = tmp18;
|
|
return collectionOf("Set", items1.call(name), items1, tmp18);
|
|
} else {
|
|
let tmp67 = name;
|
|
let tmp68 = has;
|
|
let flag4 = false;
|
|
if (has) {
|
|
let tmp69 = name;
|
|
flag4 = false;
|
|
if (tmp67) {
|
|
let tmp70 = name;
|
|
flag4 = false;
|
|
if ("object" === typeof tmp67) {
|
|
let tmp71 = has;
|
|
let tmp72 = name;
|
|
let tmp73 = has;
|
|
let callResult5 = has.call(tmp67, has);
|
|
let tmp75 = has1;
|
|
let tmp76 = name;
|
|
let tmp77 = has1;
|
|
let callResult6 = has1.call(tmp67, has1);
|
|
let tmp79 = name;
|
|
let tmp80 = globalThis;
|
|
let _WeakMap = WeakMap;
|
|
flag4 = tmp67 instanceof WeakMap;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag4) {
|
|
typeError1 = weakCollectionOf;
|
|
let str46 = "WeakMap";
|
|
return weakCollectionOf("WeakMap");
|
|
} else {
|
|
let tmp81 = name;
|
|
let tmp82 = has1;
|
|
let flag5 = false;
|
|
if (has1) {
|
|
let tmp83 = name;
|
|
flag5 = false;
|
|
if (tmp81) {
|
|
let tmp84 = name;
|
|
flag5 = false;
|
|
if ("object" === typeof tmp81) {
|
|
let tmp85 = has1;
|
|
let tmp86 = name;
|
|
let tmp87 = has1;
|
|
let callResult7 = has1.call(tmp81, has1);
|
|
let tmp89 = has;
|
|
let tmp90 = name;
|
|
let tmp91 = has;
|
|
let callResult8 = has.call(tmp81, has);
|
|
let tmp93 = name;
|
|
let tmp94 = globalThis;
|
|
let _WeakSet = WeakSet;
|
|
flag5 = tmp81 instanceof WeakSet;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag5) {
|
|
typeError1 = weakCollectionOf;
|
|
let str45 = "WeakSet";
|
|
return weakCollectionOf("WeakSet");
|
|
} else {
|
|
let tmp95 = name;
|
|
let tmp96 = deref;
|
|
let flag6 = false;
|
|
if (deref) {
|
|
let tmp97 = name;
|
|
flag6 = false;
|
|
if (tmp95) {
|
|
let tmp98 = name;
|
|
flag6 = false;
|
|
if ("object" === typeof tmp95) {
|
|
let tmp99 = deref;
|
|
typeError1 = deref.call(name);
|
|
flag6 = true;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag6) {
|
|
typeError1 = weakCollectionOf;
|
|
let str44 = "WeakRef";
|
|
return weakCollectionOf("WeakRef");
|
|
} else {
|
|
typeError1 = toStr;
|
|
let str24 = "[object Number]";
|
|
typeError1 = "[object Number]" === toStr(name);
|
|
if (typeError1) {
|
|
typeError1 = canTrustToString;
|
|
typeError1 = canTrustToString(name);
|
|
}
|
|
if (typeError1) {
|
|
typeError1 = markBoxed;
|
|
typeError1 = globalThis;
|
|
let _Number = Number;
|
|
return markBoxed(inspect(Number(name)));
|
|
} else {
|
|
let flag7 = false;
|
|
if (name) {
|
|
typeError1 = name;
|
|
flag7 = false;
|
|
if ("object" === typeof typeError1) {
|
|
typeError1 = valueOf;
|
|
flag7 = false;
|
|
if (valueOf) {
|
|
typeError1 = valueOf;
|
|
typeError1 = valueOf.call(name);
|
|
flag7 = true;
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
if (flag7) {
|
|
typeError1 = markBoxed;
|
|
typeError1 = valueOf;
|
|
return markBoxed(inspect(valueOf.call(name)));
|
|
} else {
|
|
typeError1 = toStr;
|
|
let str25 = "[object Boolean]";
|
|
typeError1 = "[object Boolean]" === toStr(name);
|
|
if (typeError1) {
|
|
typeError1 = canTrustToString;
|
|
typeError1 = canTrustToString(name);
|
|
}
|
|
if (typeError1) {
|
|
typeError1 = markBoxed;
|
|
typeError1 = valueOf;
|
|
return markBoxed(valueOf.call(name));
|
|
} else {
|
|
typeError1 = toStr;
|
|
let str26 = "[object String]";
|
|
typeError1 = "[object String]" === toStr(name);
|
|
if (typeError1) {
|
|
typeError1 = canTrustToString;
|
|
typeError1 = canTrustToString(name);
|
|
}
|
|
typeError1 = globalThis;
|
|
if (typeError1) {
|
|
typeError1 = markBoxed;
|
|
let _String2 = String;
|
|
return markBoxed(inspect(String(name)));
|
|
} else {
|
|
let _window = window;
|
|
let str27 = "undefined";
|
|
if ("undefined" !== typeof window) {
|
|
let _window2 = window;
|
|
if (name === window) {
|
|
let str43 = "{ [object Window] }";
|
|
return "{ [object Window] }";
|
|
}
|
|
}
|
|
let _globalThis = globalThis;
|
|
if ("undefined" === typeof globalThis) {
|
|
typeError1 = closure_0;
|
|
if (undefined !== closure_0) {
|
|
typeError1 = closure_0;
|
|
}
|
|
typeError1 = toStr;
|
|
let str28 = "[object Date]";
|
|
typeError1 = "[object Date]" === toStr(name);
|
|
if (typeError1) {
|
|
typeError1 = canTrustToString;
|
|
typeError1 = canTrustToString(name);
|
|
}
|
|
if (!typeError1) {
|
|
typeError1 = isRegExp;
|
|
if (!isRegExp(name)) {
|
|
typeError1 = arrObjKeys;
|
|
let arr2 = arrObjKeys(name, inspect);
|
|
typeError1 = getPrototypeOf;
|
|
if (getPrototypeOf) {
|
|
typeError1 = getPrototypeOf;
|
|
let _Object3 = Object;
|
|
typeError1 = getPrototypeOf(name) === Object.prototype;
|
|
} else {
|
|
let _Object = Object;
|
|
typeError1 = name instanceof Object;
|
|
if (!typeError1) {
|
|
let _Object2 = Object;
|
|
typeError1 = name.constructor === Object;
|
|
}
|
|
}
|
|
let _Object4 = Object;
|
|
let items2 = "null prototype";
|
|
if (name instanceof Object) {
|
|
items2 = "";
|
|
}
|
|
if (!typeError1) {
|
|
typeError1 = toStringTag;
|
|
if (toStringTag) {
|
|
let _Object5 = Object;
|
|
if (Object(name) === name) {
|
|
typeError1 = toStringTag;
|
|
if (toStringTag in name) {
|
|
typeError1 = slice;
|
|
typeError1 = toStr;
|
|
let num16 = 8;
|
|
let num17 = -1;
|
|
let callResult9 = slice.call(toStr(name), 8, -1);
|
|
}
|
|
let str30 = "";
|
|
let str31 = "";
|
|
if (!typeError1) {
|
|
str31 = str30;
|
|
if ("function" === typeof name.constructor) {
|
|
typeError1 = str30;
|
|
if (name.constructor.name) {
|
|
let str32 = " ";
|
|
typeError1 = `${name.constructor.name} `;
|
|
}
|
|
str31 = typeError1;
|
|
}
|
|
}
|
|
if (callResult9) {
|
|
typeError1 = join;
|
|
typeError1 = concat;
|
|
if (!callResult9) {
|
|
callResult9 = [];
|
|
}
|
|
if (!items2) {
|
|
items2 = [];
|
|
}
|
|
let str33 = ": ";
|
|
let str34 = "[";
|
|
let str35 = "] ";
|
|
str30 = `${"[" + tmp(tmp([], arr4, arr3), ": ")}] `;
|
|
}
|
|
typeError1 = str31 + str30;
|
|
let num18 = 0;
|
|
if (0 === arr2.length) {
|
|
let str41 = "{}";
|
|
typeError1 = `${tmp}{}`;
|
|
} else if (tmp18) {
|
|
typeError1 = indentedJoin;
|
|
let str39 = "{";
|
|
let str40 = "}";
|
|
typeError1 = `${tmp + "{" + indentedJoin(arr2, tmp18)}}`;
|
|
} else {
|
|
typeError1 = join;
|
|
let str36 = ", ";
|
|
let str37 = "{ ";
|
|
let str38 = " }";
|
|
typeError1 = `${tmp + "{ " + join.call(arr2, ", ")} }`;
|
|
}
|
|
return typeError1;
|
|
}
|
|
}
|
|
}
|
|
let str29 = "";
|
|
if (items2) {
|
|
str29 = "Object";
|
|
}
|
|
callResult9 = str29;
|
|
}
|
|
}
|
|
let _String = String;
|
|
return String(name);
|
|
} else {
|
|
let _globalThis2 = globalThis;
|
|
}
|
|
let str42 = "{ [object globalThis] }";
|
|
return "{ [object globalThis] }";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let closure_33 = Object.prototype.hasOwnProperty || (function(arg0) {
|
|
return arg0 in this;
|
|
});
|
|
|
|
export default inspect_;
|