(() => {
function isAnyArrayBuffer(value) {
return value instanceof ArrayBuffer || value instanceof SharedArrayBuffer;
}
function isArgumentsObject(value) {
return Object.prototype.toString.call(value) === "[object Arguments]";
}
function isArrayBuffer(value) {
return value instanceof ArrayBuffer;
}
function isAsyncFunction(value) {
return typeof value === "function" && value.constructor && value.constructor.name === "AsyncFunction";
}
function isBigIntObject(value) {
return typeof value === "object" && value !== null && typeof value.bigIntValue === "bigint";
}
function isBooleanObject(value) {
return typeof value === "object" && value !== null && typeof value.valueOf() === "boolean";
}
function isBoxedPrimitive(value) {
return typeof value === "object" && value !== null && Object(value) === value;
}
function isDataView(value) {
return value instanceof DataView;
}
function isDate(value) {
return value instanceof Date;
}
function isGeneratorFunction(value) {
return typeof value === "function" && value.constructor && value.constructor.name === "GeneratorFunction";
}
function isGeneratorObject(value) {
return typeof value === "object" && typeof value.next === "function" && typeof value.throw === "function";
}
function isMapIterator(value) {
return typeof value === "object" && value !== null && typeof value.next === "function";
}
function isModuleNamespaceObject(value) {
return typeof value === "object" && value !== null && typeof value === "object" && "exports" in value;
}
function isNativeError(value) {
return typeof value === "object" && value !== null && value instanceof Error;
}
function isNumberObject(value) {
return typeof value === "object" && value !== null && value instanceof Number;
}
function isPromise(value) {
return typeof value === "object" && value !== null && typeof value.then === "function";
}
function isProxy(value) {
return typeof value === "function" && typeof value.revocable === "function";
}
function isMap(value) {
return value instanceof Map;
}
function isRegExp(value) {
return value instanceof RegExp;
}
function isSet(value) {
return value instanceof Set;
}
function isSetIterator(value) {
return typeof value === "object" && value !== null && typeof value.next === "function";
}
function isSharedArrayBuffer(value) {
return value instanceof SharedArrayBuffer;
}
function isStringObject(value) {
return typeof value === "object" && value !== null && typeof value.valueOf === "function" && typeof value.toString === "function";
}
function isSymbolObject(value) {
return typeof value === "object" && value !== null && typeof value.valueOf === "function" && typeof value.toString === "function";
}
function isTypedArray(value) {
return ArrayBuffer.isView(value);
}
function isWeakMap(value) {
return value instanceof WeakMap;
}
function isWeakSet(value) {
return value instanceof WeakSet;
}
var core_default = () => {
const ALL_PROPERTIES = 0;
const ONLY_WRITABLE = 1;
const ONLY_ENUMERABLE = 2;
const ONLY_CONFIGURABLE = 4;
const ONLY_ENUM_WRITABLE = 6;
const SKIP_STRINGS = 8;
const SKIP_SYMBOLS = 16;
const isNumericLookup = {};
function isArrayIndex(value) {
switch (typeof value) {
case "number":
return value >= 0 && (value | 0) === value;
case "string": {
const result = isNumericLookup[value];
if (result !== void 0) {
return result;
}
const length = value.length;
if (length === 0) {
return isNumericLookup[value] = false;
}
let ch = 0;
let i = 0;
for (; i < length; ++i) {
ch = value.charCodeAt(i);
if (i === 0 && ch === 48 && length > 1 || ch < 48 || ch > 57) {
return isNumericLookup[value] = false;
}
}
return isNumericLookup[value] = true;
}
default:
return false;
}
}
function getOwnNonIndexProperties(obj, filter) {
let allProperties = [
...Object.getOwnPropertyNames(obj),
...Object.getOwnPropertySymbols(obj)
];
if (Array.isArray(obj)) {
allProperties = allProperties.filter((k) => !isArrayIndex(k));
}
if (filter === ALL_PROPERTIES) {
return allProperties;
}
const result = [];
for (const key of allProperties) {
const desc = Object.getOwnPropertyDescriptor(obj, key);
if (desc === void 0) {
continue;
}
if (filter & ONLY_WRITABLE && !desc.writable) {
continue;
}
if (filter & ONLY_ENUMERABLE && !desc.enumerable) {
continue;
}
if (filter & ONLY_CONFIGURABLE && !desc.configurable) {
continue;
}
if (filter & SKIP_STRINGS && typeof key === "string") {
continue;
}
if (filter & SKIP_SYMBOLS && typeof key === "symbol") {
continue;
}
result.push(key);
}
return result;
}
const internals = {};
const primordials = {};
primordials.ArrayBufferPrototypeGetByteLength = (that) => {
if (!ArrayBuffer.isView(that)) {
throw new Error();
}
that.byteLength;
};
primordials.ArrayPrototypePushApply = (that, ...args) => that.push(...args);
primordials.MapPrototypeGetSize = (that) => that.size;
primordials.RegExpPrototypeSymbolReplace = (that, ...args) => RegExp.prototype[Symbol.replace].call(that, ...args);
primordials.SafeArrayIterator = class SafeArrayIterator {
constructor(array) {
this.array = [...array];
this.index = 0;
}
next() {
if (this.index < this.array.length) {
return { value: this.array[this.index++], done: false };
} else {
return { done: true };
}
}
[Symbol.iterator]() {
return this;
}
};
primordials.SafeMap = Map;
primordials.SafeMapIterator = class SafeMapIterator {
get [Symbol.toStringTag]() {
return "Map Iterator";
}
constructor(map) {
this.map = map;
this.keys = Array.from(map.keys());
this.index = 0;
}
next() {
if (this.index < this.keys.length) {
const key = this.keys[this.index];
const value = this.map.get(key);
this.index++;
return { value: [key, value], done: false };
} else {
return { done: true };
}
}
[Symbol.iterator]() {
return this;
}
};
primordials.SafeRegExp = RegExp;
primordials.SafeSet = Set;
primordials.SafeSetIterator = class SafeSetIterator {
get [Symbol.toStringTag]() {
return "Set Iterator";
}
constructor(set) {
this.set = set;
this.values = Array.from(set);
this.index = 0;
}
next() {
if (this.index < this.values.length) {
const value = this.values[this.index];
this.index++;
return { value, done: false };
} else {
return { done: true };
}
}
[Symbol.iterator]() {
return this;
}
};
primordials.SafeStringIterator = class SafeStringIterator {
get [Symbol.toStringTag]() {
return "String Iterator";
}
constructor(str) {
this.str = str;
this.index = 0;
}
next() {
if (this.index < this.str.length) {
const char = this.str[this.index];
this.index++;
return { value: char, done: false };
} else {
return { done: true };
}
}
[Symbol.iterator]() {
return this;
}
};
primordials.SetPrototypeGetSize = (that) => that.size;
primordials.SymbolPrototypeGetDescription = (that) => that.description;
primordials.TypedArrayPrototypeGetByteLength = (that) => that.byteLength;
primordials.TypedArrayPrototypeGetLength = (that) => that.length;
primordials.TypedArrayPrototypeGetSymbolToStringTag = (that) => {
if (ArrayBuffer.isView(that)) {
return that[Symbol.toStringTag];
}
};
primordials.ObjectPrototype = Object.prototype;
primordials.ObjectPrototypeIsPrototypeOf = (that, ...args) => Object.prototype.isPrototypeOf.call(that, ...args);
primordials.ObjectPrototypePropertyIsEnumerable = (that, ...args) => Object.prototype.propertyIsEnumerable.call(that, ...args);
primordials.ObjectPrototypeToString = (that, ...args) => Object.prototype.toString.call(that, ...args);
primordials.ObjectAssign = (...args) => Object.assign(...args);
primordials.ObjectGetOwnPropertyDescriptor = (...args) => Object.getOwnPropertyDescriptor(...args);
primordials.ObjectGetOwnPropertyNames = (...args) => Object.getOwnPropertyNames(...args);
primordials.ObjectGetOwnPropertySymbols = (...args) => Object.getOwnPropertySymbols(...args);
primordials.ObjectHasOwn = (...args) => Object.hasOwn(...args);
primordials.ObjectIs = (...args) => Object.is(...args);
primordials.ObjectCreate = (...args) => Object.create(...args);
primordials.ObjectDefineProperty = (...args) => Object.defineProperty(...args);
primordials.ObjectFreeze = (...args) => Object.freeze(...args);
primordials.ObjectGetPrototypeOf = (...args) => Object.getPrototypeOf(...args);
primordials.ObjectSetPrototypeOf = (...args) => Object.setPrototypeOf(...args);
primordials.ObjectKeys = (...args) => Object.keys(...args);
primordials.ObjectFromEntries = (...args) => Object.fromEntries(...args);
primordials.ObjectValues = (...args) => Object.values(...args);
primordials.FunctionPrototypeBind = (that, ...args) => Function.prototype.bind.call(that, ...args);
primordials.FunctionPrototypeCall = (that, ...args) => Function.prototype.call.call(that, ...args);
primordials.FunctionPrototypeToString = (that, ...args) => Function.prototype.toString.call(that, ...args);
primordials.Array = Array;
primordials.ArrayPrototypeFill = (that, ...args) => Array.prototype.fill.call(that, ...args);
primordials.ArrayPrototypeFind = (that, ...args) => Array.prototype.find.call(that, ...args);
primordials.ArrayPrototypePop = (that, ...args) => Array.prototype.pop.call(that, ...args);
primordials.ArrayPrototypePush = (that, ...args) => Array.prototype.push.call(that, ...args);
primordials.ArrayPrototypeShift = (that, ...args) => Array.prototype.shift.call(that, ...args);
primordials.ArrayPrototypeUnshift = (that, ...args) => Array.prototype.unshift.call(that, ...args);
primordials.ArrayPrototypeSlice = (that, ...args) => Array.prototype.slice.call(that, ...args);
primordials.ArrayPrototypeSort = (that, ...args) => Array.prototype.sort.call(that, ...args);
primordials.ArrayPrototypeSplice = (that, ...args) => Array.prototype.splice.call(that, ...args);
primordials.ArrayPrototypeIncludes = (that, ...args) => Array.prototype.includes.call(that, ...args);
primordials.ArrayPrototypeJoin = (that, ...args) => Array.prototype.join.call(that, ...args);
primordials.ArrayPrototypeForEach = (that, ...args) => Array.prototype.forEach.call(that, ...args);
primordials.ArrayPrototypeFilter = (that, ...args) => Array.prototype.filter.call(that, ...args);
primordials.ArrayPrototypeMap = (that, ...args) => Array.prototype.map.call(that, ...args);
primordials.ArrayPrototypeReduce = (that, ...args) => Array.prototype.reduce.call(that, ...args);
primordials.ArrayIsArray = (...args) => Array.isArray(...args);
primordials.Number = Number;
primordials.NumberPrototypeToString = (that, ...args) => Number.prototype.toString.call(that, ...args);
primordials.NumberPrototypeValueOf = (that, ...args) => Number.prototype.valueOf.call(that, ...args);
primordials.NumberIsInteger = (...args) => Number.isInteger(...args);
primordials.NumberParseInt = (...args) => Number.parseInt(...args);
primordials.Boolean = Boolean;
primordials.BooleanPrototypeValueOf = (that, ...args) => Boolean.prototype.valueOf.call(that, ...args);
primordials.String = String;
primordials.StringPrototypeCharCodeAt = (that, ...args) => String.prototype.charCodeAt.call(that, ...args);
primordials.StringPrototypeCodePointAt = (that, ...args) => String.prototype.codePointAt.call(that, ...args);
primordials.StringPrototypeEndsWith = (that, ...args) => String.prototype.endsWith.call(that, ...args);
primordials.StringPrototypeIncludes = (that, ...args) => String.prototype.includes.call(that, ...args);
primordials.StringPrototypeIndexOf = (that, ...args) => String.prototype.indexOf.call(that, ...args);
primordials.StringPrototypeLastIndexOf = (that, ...args) => String.prototype.lastIndexOf.call(that, ...args);
primordials.StringPrototypeMatch = (that, ...args) => String.prototype.match.call(that, ...args);
primordials.StringPrototypeNormalize = (that, ...args) => String.prototype.normalize.call(that, ...args);
primordials.StringPrototypePadEnd = (that, ...args) => String.prototype.padEnd.call(that, ...args);
primordials.StringPrototypePadStart = (that, ...args) => String.prototype.padStart.call(that, ...args);
primordials.StringPrototypeRepeat = (that, ...args) => String.prototype.repeat.call(that, ...args);
primordials.StringPrototypeReplace = (that, ...args) => String.prototype.replace.call(that, ...args);
primordials.StringPrototypeReplaceAll = (that, ...args) => String.prototype.replaceAll.call(that, ...args);
primordials.StringPrototypeSlice = (that, ...args) => String.prototype.slice.call(that, ...args);
primordials.StringPrototypeSplit = (that, ...args) => String.prototype.split.call(that, ...args);
primordials.StringPrototypeStartsWith = (that, ...args) => String.prototype.startsWith.call(that, ...args);
primordials.StringPrototypeTrim = (that, ...args) => String.prototype.trim.call(that, ...args);
primordials.StringPrototypeToLowerCase = (that, ...args) => String.prototype.toLowerCase.call(that, ...args);
primordials.StringPrototypeValueOf = (that, ...args) => String.prototype.valueOf.call(that, ...args);
primordials.Symbol = Symbol;
primordials.SymbolPrototypeToString = (that, ...args) => Symbol.prototype.toString.call(that, ...args);
primordials.SymbolPrototypeValueOf = (that, ...args) => Symbol.prototype.valueOf.call(that, ...args);
primordials.SymbolFor = (...args) => Symbol.for(...args);
primordials.SymbolHasInstance = Symbol.hasInstance;
primordials.SymbolIterator = Symbol.iterator;
primordials.SymbolToStringTag = Symbol.toStringTag;
primordials.DatePrototype = Date.prototype;
primordials.DatePrototypeToISOString = (that, ...args) => Date.prototype.toISOString.call(that, ...args);
primordials.DatePrototypeGetTime = (that, ...args) => Date.prototype.getTime.call(that, ...args);
primordials.DateNow = (...args) => Date.now(...args);
primordials.RegExpPrototypeExec = (that, ...args) => RegExp.prototype.exec.call(that, ...args);
primordials.RegExpPrototypeToString = (that, ...args) => RegExp.prototype.toString.call(that, ...args);
primordials.RegExpPrototypeTest = (that, ...args) => RegExp.prototype.test.call(that, ...args);
primordials.Error = Error;
primordials.ErrorPrototype = Error.prototype;
primordials.ErrorPrototypeToString = (that, ...args) => Error.prototype.toString.call(that, ...args);
primordials.ErrorCaptureStackTrace = (...args) => Error.captureStackTrace(...args);
primordials.AggregateErrorPrototype = AggregateError.prototype;
primordials.MathAbs = (...args) => Math.abs(...args);
primordials.MathFloor = (...args) => Math.floor(...args);
primordials.MathMax = (...args) => Math.max(...args);
primordials.MathMin = (...args) => Math.min(...args);
primordials.MathRound = (...args) => Math.round(...args);
primordials.MathSqrt = (...args) => Math.sqrt(...args);
primordials.ArrayBufferIsView = (...args) => ArrayBuffer.isView(...args);
primordials.Uint8Array = Uint8Array;
primordials.MapPrototype = Map.prototype;
primordials.MapPrototypeGet = (that, ...args) => Map.prototype.get.call(that, ...args);
primordials.MapPrototypeSet = (that, ...args) => Map.prototype.set.call(that, ...args);
primordials.MapPrototypeHas = (that, ...args) => Map.prototype.has.call(that, ...args);
primordials.MapPrototypeDelete = (that, ...args) => Map.prototype.delete.call(that, ...args);
primordials.MapPrototypeEntries = (that, ...args) => Map.prototype.entries.call(that, ...args);
primordials.MapPrototypeForEach = (that, ...args) => Map.prototype.forEach.call(that, ...args);
primordials.BigIntPrototypeValueOf = (that, ...args) => BigInt.prototype.valueOf.call(that, ...args);
primordials.SetPrototype = Set.prototype;
primordials.SetPrototypeHas = (that, ...args) => Set.prototype.has.call(that, ...args);
primordials.SetPrototypeAdd = (that, ...args) => Set.prototype.add.call(that, ...args);
primordials.SetPrototypeValues = (that, ...args) => Set.prototype.values.call(that, ...args);
primordials.WeakMapPrototypeHas = (that, ...args) => WeakMap.prototype.has.call(that, ...args);
primordials.WeakSetPrototypeHas = (that, ...args) => WeakSet.prototype.has.call(that, ...args);
primordials.Proxy = Proxy;
primordials.ReflectGet = (...args) => Reflect.get(...args);
primordials.ReflectGetOwnPropertyDescriptor = (...args) => Reflect.getOwnPropertyDescriptor(...args);
primordials.ReflectGetPrototypeOf = (...args) => Reflect.getPrototypeOf(...args);
primordials.ReflectHas = (...args) => Reflect.has(...args);
primordials.ReflectOwnKeys = (...args) => Reflect.ownKeys(...args);
const ops = {
op_get_non_index_property_names: getOwnNonIndexProperties,
op_get_constructor_name(v) {
return Object.prototype.toString.call(v).slice(8, -1);
}
};
globalThis.Deno = {
core: {
ops,
getPromiseDetails() {
return [-1, Symbol("UNKNOWN")];
},
getProxyDetails() {
return null;
},
isAnyArrayBuffer,
isArgumentsObject,
isArrayBuffer,
isAsyncFunction,
isBigIntObject,
isBooleanObject,
isBoxedPrimitive,
isDataView,
isDate,
isGeneratorFunction,
isGeneratorObject,
isMap,
isMapIterator,
isModuleNamespaceObject,
isNativeError,
isNumberObject,
isPromise,
isProxy,
isRegExp,
isSet,
isSetIterator,
isSharedArrayBuffer,
isStringObject,
isSymbolObject,
isTypedArray,
isWeakMap,
isWeakSet,
op_get_non_index_property_names: getOwnNonIndexProperties
}
};
globalThis.__bootstrap = {
internals,
primordials
};
};
var console_default = (noColorStdout, noColorStderr) => {
const core = globalThis.Deno.core;
const primordials = globalThis.__bootstrap.primordials;
const {
isAnyArrayBuffer: isAnyArrayBuffer2,
isArgumentsObject: isArgumentsObject2,
isArrayBuffer: isArrayBuffer2,
isAsyncFunction: isAsyncFunction2,
isBigIntObject: isBigIntObject2,
isBooleanObject: isBooleanObject2,
isBoxedPrimitive: isBoxedPrimitive2,
isDataView: isDataView2,
isDate: isDate2,
isGeneratorFunction: isGeneratorFunction2,
isMap: isMap2,
isMapIterator: isMapIterator2,
isModuleNamespaceObject: isModuleNamespaceObject2,
isNativeError: isNativeError2,
isNumberObject: isNumberObject2,
isPromise: isPromise2,
isRegExp: isRegExp2,
isSet: isSet2,
isSetIterator: isSetIterator2,
isStringObject: isStringObject2,
isTypedArray: isTypedArray2,
isWeakMap: isWeakMap2,
isWeakSet: isWeakSet2
} = core;
const {
op_get_constructor_name,
op_get_non_index_property_names,
op_preview_entries
} = core;
const {
Array: Array2,
ArrayBufferPrototypeGetByteLength,
ArrayIsArray,
ArrayPrototypeFill,
ArrayPrototypeFilter,
ArrayPrototypeFind,
ArrayPrototypeForEach,
ArrayPrototypeIncludes,
ArrayPrototypeJoin,
ArrayPrototypeMap,
ArrayPrototypePop,
ArrayPrototypePush,
ArrayPrototypePushApply,
ArrayPrototypeReduce,
ArrayPrototypeShift,
ArrayPrototypeSlice,
ArrayPrototypeSort,
ArrayPrototypeSplice,
ArrayPrototypeUnshift,
BigIntPrototypeValueOf,
Boolean: Boolean2,
BooleanPrototypeValueOf,
DateNow,
DatePrototypeGetTime,
DatePrototypeToISOString,
Error: Error2,
ErrorCaptureStackTrace,
ErrorPrototype,
ErrorPrototypeToString,
FunctionPrototypeBind,
FunctionPrototypeCall,
FunctionPrototypeToString,
MapPrototypeDelete,
MapPrototypeEntries,
MapPrototypeForEach,
MapPrototypeGet,
MapPrototypeGetSize,
MapPrototypeHas,
MapPrototypeSet,
MathAbs,
MathFloor,
MathMax,
MathMin,
MathRound,
MathSqrt,
Number: Number2,
NumberIsInteger,
NumberIsNaN,
NumberParseInt,
NumberPrototypeToString,
NumberPrototypeValueOf,
ObjectAssign,
ObjectCreate,
ObjectDefineProperty,
ObjectFreeze,
ObjectFromEntries,
ObjectGetOwnPropertyDescriptor,
ObjectGetOwnPropertyNames,
ObjectGetOwnPropertySymbols,
ObjectGetPrototypeOf,
ObjectHasOwn,
ObjectIs,
ObjectKeys,
ObjectPrototype,
ObjectPrototypeIsPrototypeOf,
ObjectPrototypePropertyIsEnumerable,
ObjectSetPrototypeOf,
ObjectValues,
Proxy: Proxy2,
ReflectGet,
ReflectGetOwnPropertyDescriptor,
ReflectGetPrototypeOf,
ReflectHas,
ReflectOwnKeys,
RegExpPrototypeExec,
RegExpPrototypeSymbolReplace,
RegExpPrototypeTest,
RegExpPrototypeToString,
SafeArrayIterator,
SafeMap,
SafeMapIterator,
SafeRegExp,
SafeSet,
SafeSetIterator,
SafeStringIterator,
SetPrototypeAdd,
SetPrototypeGetSize,
SetPrototypeHas,
SetPrototypeValues,
String: String2,
StringPrototypeCharCodeAt,
StringPrototypeCodePointAt,
StringPrototypeEndsWith,
StringPrototypeIncludes,
StringPrototypeIndexOf,
StringPrototypeLastIndexOf,
StringPrototypeMatch,
StringPrototypeNormalize,
StringPrototypePadEnd,
StringPrototypePadStart,
StringPrototypeRepeat,
StringPrototypeReplace,
StringPrototypeReplaceAll,
StringPrototypeSlice,
StringPrototypeSplit,
StringPrototypeStartsWith,
StringPrototypeToLowerCase,
StringPrototypeTrim,
StringPrototypeValueOf,
Symbol: Symbol2,
SymbolFor,
SymbolHasInstance,
SymbolIterator,
SymbolPrototypeGetDescription,
SymbolPrototypeToString,
SymbolPrototypeValueOf,
SymbolToStringTag,
TypedArrayPrototypeGetByteLength,
TypedArrayPrototypeGetLength,
Uint8Array: Uint8Array2
} = primordials;
class AssertionError extends Error2 {
name = "AssertionError";
constructor(message) {
super(message);
}
}
function assert(cond, msg = "Assertion failed.") {
if (!cond) {
throw new AssertionError(msg);
}
}
const styles = {
special: "cyan",
number: "yellow",
bigint: "yellow",
boolean: "yellow",
undefined: "grey",
null: "bold",
string: "green",
symbol: "green",
date: "magenta",
regexp: "red",
module: "underline",
internalError: "red",
temporal: "magenta"
};
const defaultFG = 39;
const defaultBG = 49;
const colors = {
reset: [0, 0],
bold: [1, 22],
dim: [2, 22],
italic: [3, 23],
underline: [4, 24],
blink: [5, 25],
inverse: [7, 27],
hidden: [8, 28],
strikethrough: [9, 29],
doubleunderline: [21, 24],
black: [30, defaultFG],
red: [31, defaultFG],
green: [32, defaultFG],
yellow: [33, defaultFG],
blue: [34, defaultFG],
magenta: [35, defaultFG],
cyan: [36, defaultFG],
white: [37, defaultFG],
bgBlack: [40, defaultBG],
bgRed: [41, defaultBG],
bgGreen: [42, defaultBG],
bgYellow: [43, defaultBG],
bgBlue: [44, defaultBG],
bgMagenta: [45, defaultBG],
bgCyan: [46, defaultBG],
bgWhite: [47, defaultBG],
framed: [51, 54],
overlined: [53, 55],
gray: [90, defaultFG],
redBright: [91, defaultFG],
greenBright: [92, defaultFG],
yellowBright: [93, defaultFG],
blueBright: [94, defaultFG],
magentaBright: [95, defaultFG],
cyanBright: [96, defaultFG],
whiteBright: [97, defaultFG],
bgGray: [100, defaultBG],
bgRedBright: [101, defaultBG],
bgGreenBright: [102, defaultBG],
bgYellowBright: [103, defaultBG],
bgBlueBright: [104, defaultBG],
bgMagentaBright: [105, defaultBG],
bgCyanBright: [106, defaultBG],
bgWhiteBright: [107, defaultBG]
};
function defineColorAlias(target, alias) {
ObjectDefineProperty(colors, alias, {
get() {
return this[target];
},
set(value) {
this[target] = value;
},
configurable: true,
enumerable: false
});
}
defineColorAlias("gray", "grey");
defineColorAlias("gray", "blackBright");
defineColorAlias("bgGray", "bgGrey");
defineColorAlias("bgGray", "bgBlackBright");
defineColorAlias("dim", "faint");
defineColorAlias("strikethrough", "crossedout");
defineColorAlias("strikethrough", "strikeThrough");
defineColorAlias("strikethrough", "crossedOut");
defineColorAlias("hidden", "conceal");
defineColorAlias("inverse", "swapColors");
defineColorAlias("inverse", "swapcolors");
defineColorAlias("doubleunderline", "doubleUnderline");
let _getSharedArrayBufferByteLength;
function getSharedArrayBufferByteLength(value) {
_getSharedArrayBufferByteLength ??= ObjectGetOwnPropertyDescriptor(
SharedArrayBuffer.prototype,
"byteLength"
).get;
return FunctionPrototypeCall(_getSharedArrayBufferByteLength, value);
}
function isAggregateError(value) {
return isNativeError2(value) && value.name === "AggregateError" && ArrayIsArray(value.errors);
}
const kObjectType = 0;
const kArrayType = 1;
const kArrayExtrasType = 2;
const kMinLineLength = 16;
const kWeak = 0;
const kIterator = 1;
const kMapEntries = 2;
const meta = [
"\\x00",
"\\x01",
"\\x02",
"\\x03",
"\\x04",
"\\x05",
"\\x06",
"\\x07",
"\\b",
"\\t",
"\\n",
"\\x0B",
"\\f",
"\\r",
"\\x0E",
"\\x0F",
"\\x10",
"\\x11",
"\\x12",
"\\x13",
"\\x14",
"\\x15",
"\\x16",
"\\x17",
"\\x18",
"\\x19",
"\\x1A",
"\\x1B",
"\\x1C",
"\\x1D",
"\\x1E",
"\\x1F",
"",
"",
"",
"",
"",
"",
"",
"\\'",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"\\\\",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"\\x7F",
"\\x80",
"\\x81",
"\\x82",
"\\x83",
"\\x84",
"\\x85",
"\\x86",
"\\x87",
"\\x88",
"\\x89",
"\\x8A",
"\\x8B",
"\\x8C",
"\\x8D",
"\\x8E",
"\\x8F",
"\\x90",
"\\x91",
"\\x92",
"\\x93",
"\\x94",
"\\x95",
"\\x96",
"\\x97",
"\\x98",
"\\x99",
"\\x9A",
"\\x9B",
"\\x9C",
"\\x9D",
"\\x9E",
"\\x9F"
];
const isUndetectableObject = (v) => typeof v === "undefined" && v !== void 0;
const strEscapeSequencesReplacer = new SafeRegExp(
"[\0- '\\\x7F-\x9F]",
"g"
);
const keyStrRegExp = new SafeRegExp("^[a-zA-Z_][a-zA-Z_0-9]*$");
const numberRegExp = new SafeRegExp("^(0|[1-9][0-9]*)$");
const escapeFn = (str) => meta[StringPrototypeCharCodeAt(str, 0)];
function stylizeNoColor(str) {
return str;
}
const nodeCustomInspectSymbol = SymbolFor("nodejs.util.inspect.custom");
const privateCustomInspect = SymbolFor("Deno.privateCustomInspect");
function getUserOptions(ctx, isCrossContext) {
const ret = {
stylize: ctx.stylize,
showHidden: ctx.showHidden,
depth: ctx.depth,
colors: ctx.colors,
customInspect: ctx.customInspect,
showProxy: ctx.showProxy,
maxArrayLength: ctx.maxArrayLength,
maxStringLength: ctx.maxStringLength,
breakLength: ctx.breakLength,
compact: ctx.compact,
sorted: ctx.sorted,
getters: ctx.getters,
numericSeparator: ctx.numericSeparator,
...ctx.userOptions
};
if (isCrossContext) {
ObjectSetPrototypeOf(ret, null);
for (const key of new SafeArrayIterator(ObjectKeys(ret))) {
if ((typeof ret[key] === "object" || typeof ret[key] === "function") && ret[key] !== null) {
delete ret[key];
}
}
ret.stylize = ObjectSetPrototypeOf((value, flavour) => {
let stylized;
try {
stylized = `${ctx.stylize(value, flavour)}`;
} catch {
}
if (typeof stylized !== "string")
return value;
return stylized;
}, null);
}
return ret;
}
function formatValue(ctx, value, recurseTimes, typedArray) {
if (typeof value !== "object" && typeof value !== "function" && !isUndetectableObject(value)) {
return formatPrimitive(ctx.stylize, value, ctx);
}
if (value === null) {
return ctx.stylize("null", "null");
}
const context = value;
const proxyDetails = core.getProxyDetails(value);
if (ctx.customInspect) {
if (ReflectHas(value, customInspect) && typeof value[customInspect] === "function") {
return String2(value[customInspect](inspect, ctx));
} else if (ReflectHas(value, privateCustomInspect) && typeof value[privateCustomInspect] === "function") {
return String2(value[privateCustomInspect](inspect, ctx));
} else if (ReflectHas(value, nodeCustomInspectSymbol)) {
const maybeCustom = value[nodeCustomInspectSymbol];
if (typeof maybeCustom === "function" && maybeCustom !== ctx.inspect && !(value.constructor && value.constructor.prototype === value)) {
const depth = ctx.depth === null ? null : ctx.depth - recurseTimes;
const isCrossContext = !ObjectPrototypeIsPrototypeOf(
ObjectPrototype,
context
);
const ret = FunctionPrototypeCall(
maybeCustom,
context,
depth,
getUserOptions(ctx, isCrossContext),
ctx.inspect
);
if (ret !== context) {
if (typeof ret !== "string") {
return formatValue(ctx, ret, recurseTimes);
}
return StringPrototypeReplaceAll(
ret,
"\n",
`
${StringPrototypeRepeat(" ", ctx.indentationLvl)}`
);
}
}
}
}
if (ArrayPrototypeIncludes(ctx.seen, value)) {
let index = 1;
if (ctx.circular === void 0) {
ctx.circular = new SafeMap();
MapPrototypeSet(ctx.circular, value, index);
} else {
index = ctx.circular.get(value);
if (index === void 0) {
index = ctx.circular.size + 1;
MapPrototypeSet(ctx.circular, value, index);
}
}
return ctx.stylize(`[Circular *${index}]`, "special");
}
return formatRaw(ctx, value, recurseTimes, typedArray, proxyDetails);
}
function getClassBase(value, constructor, tag) {
const hasName = ObjectHasOwn(value, "name");
const name = hasName && value.name || "(anonymous)";
let base = `class ${name}`;
if (constructor !== "Function" && constructor !== null) {
base += ` [${constructor}]`;
}
if (tag !== "" && constructor !== tag) {
base += ` [${tag}]`;
}
if (constructor !== null) {
const superName = ObjectGetPrototypeOf(value).name;
if (superName) {
base += ` extends ${superName}`;
}
} else {
base += " extends [null prototype]";
}
return `[${base}]`;
}
const stripCommentsRegExp = new SafeRegExp(
"(\\/\\/.*?\\n)|(\\/\\*(.|\\n)*?\\*\\/)",
"g"
);
const classRegExp = new SafeRegExp("^(\\s+[^(]*?)\\s*{");
function getFunctionBase(value, constructor, tag) {
const stringified = FunctionPrototypeToString(value);
if (StringPrototypeStartsWith(stringified, "class") && StringPrototypeEndsWith(stringified, "}")) {
const slice = StringPrototypeSlice(stringified, 5, -1);
const bracketIndex = StringPrototypeIndexOf(slice, "{");
if (bracketIndex !== -1 && (!StringPrototypeIncludes(
StringPrototypeSlice(slice, 0, bracketIndex),
"("
) || RegExpPrototypeExec(
classRegExp,
RegExpPrototypeSymbolReplace(stripCommentsRegExp, slice)
) !== null)) {
return getClassBase(value, constructor, tag);
}
}
let type = "Function";
if (isGeneratorFunction2(value)) {
type = `Generator${type}`;
}
if (isAsyncFunction2(value)) {
type = `Async${type}`;
}
let base = `[${type}`;
if (constructor === null) {
base += " (null prototype)";
}
if (value.name === "") {
base += " (anonymous)";
} else {
base += `: ${value.name}`;
}
base += "]";
if (constructor !== type && constructor !== null) {
base += ` ${constructor}`;
}
if (tag !== "" && constructor !== tag) {
base += ` [${tag}]`;
}
return base;
}
function formatRaw(ctx, value, recurseTimes, typedArray, proxyDetails) {
let keys;
let protoProps;
if (ctx.showHidden && (recurseTimes <= ctx.depth || ctx.depth === null)) {
protoProps = [];
}
const constructor = getConstructorName(value, ctx, recurseTimes, protoProps);
if (protoProps !== void 0 && protoProps.length === 0) {
protoProps = void 0;
}
let tag = value[SymbolToStringTag];
if (typeof tag !== "string") {
tag = "";
}
let base = "";
let formatter = () => [];
let braces;
let noIterator = true;
let i = 0;
const filter = ctx.showHidden ? 0 : 2;
let extrasType = kObjectType;
if (proxyDetails !== null && ctx.showProxy) {
return `Proxy ` + formatValue(ctx, proxyDetails, recurseTimes);
} else {
if (ReflectHas(value, SymbolIterator) || constructor === null) {
noIterator = false;
if (ArrayIsArray(value)) {
const prefix = constructor !== "Array" || tag !== "" ? getPrefix(constructor, tag, "Array", `(${value.length})`) : "";
keys = op_get_non_index_property_names(value, filter);
braces = [`${prefix}[`, "]"];
if (value.length === 0 && keys.length === 0 && protoProps === void 0) {
return `${braces[0]}]`;
}
extrasType = kArrayExtrasType;
formatter = formatArray;
} else if (proxyDetails === null && isSet2(value) || proxyDetails !== null && isSet2(proxyDetails[0])) {
const set = proxyDetails?.[0] ?? value;
const size = SetPrototypeGetSize(set);
const prefix = getPrefix(constructor, tag, "Set", `(${size})`);
keys = getKeys(set, ctx.showHidden);
formatter = constructor !== null ? FunctionPrototypeBind(formatSet, null, set) : FunctionPrototypeBind(formatSet, null, SetPrototypeValues(set));
if (size === 0 && keys.length === 0 && protoProps === void 0) {
return `${prefix}{}`;
}
braces = [`${prefix}{`, "}"];
} else if (proxyDetails === null && isMap2(value) || proxyDetails !== null && isMap2(proxyDetails[0])) {
const map = proxyDetails?.[0] ?? value;
const size = MapPrototypeGetSize(map);
const prefix = getPrefix(constructor, tag, "Map", `(${size})`);
keys = getKeys(map, ctx.showHidden);
formatter = constructor !== null ? FunctionPrototypeBind(formatMap, null, map) : FunctionPrototypeBind(formatMap, null, MapPrototypeEntries(map));
if (size === 0 && keys.length === 0 && protoProps === void 0) {
return `${prefix}{}`;
}
braces = [`${prefix}{`, "}"];
} else if (proxyDetails === null && isTypedArray2(value) || proxyDetails !== null && isTypedArray2(proxyDetails[0])) {
const typedArray2 = proxyDetails?.[0] ?? value;
keys = op_get_non_index_property_names(typedArray2, filter);
const bound = typedArray2;
const fallback = "";
if (constructor === null) {
}
const size = TypedArrayPrototypeGetLength(typedArray2);
const prefix = getPrefix(constructor, tag, fallback, `(${size})`);
braces = [`${prefix}[`, "]"];
if (typedArray2.length === 0 && keys.length === 0 && !ctx.showHidden) {
return `${braces[0]}]`;
}
formatter = FunctionPrototypeBind(formatTypedArray, null, bound, size);
extrasType = kArrayExtrasType;
} else if (proxyDetails === null && isMapIterator2(value) || proxyDetails !== null && isMapIterator2(proxyDetails[0])) {
const mapIterator = proxyDetails?.[0] ?? value;
keys = getKeys(mapIterator, ctx.showHidden);
braces = getIteratorBraces("Map", tag);
formatter = FunctionPrototypeBind(formatIterator, null, braces);
} else if (proxyDetails === null && isSetIterator2(value) || proxyDetails !== null && isSetIterator2(proxyDetails[0])) {
const setIterator = proxyDetails?.[0] ?? value;
keys = getKeys(setIterator, ctx.showHidden);
braces = getIteratorBraces("Set", tag);
formatter = FunctionPrototypeBind(formatIterator, null, braces);
} else {
noIterator = true;
}
}
if (noIterator) {
keys = getKeys(value, ctx.showHidden);
braces = ["{", "}"];
if (constructor === "Object") {
if (isArgumentsObject2(value)) {
braces[0] = "[Arguments] {";
} else if (tag !== "") {
braces[0] = `${getPrefix(constructor, tag, "Object")}{`;
}
if (keys.length === 0 && protoProps === void 0) {
return `${braces[0]}}`;
}
} else if (typeof value === "function") {
base = getFunctionBase(value, constructor, tag);
if (keys.length === 0 && protoProps === void 0) {
return ctx.stylize(base, "special");
}
} else if (proxyDetails === null && isRegExp2(value) || proxyDetails !== null && isRegExp2(proxyDetails[0])) {
const regExp = proxyDetails?.[0] ?? value;
base = RegExpPrototypeToString(
constructor !== null ? regExp : new SafeRegExp(regExp)
);
const prefix = getPrefix(constructor, tag, "RegExp");
if (prefix !== "RegExp ") {
base = `${prefix}${base}`;
}
if (keys.length === 0 && protoProps === void 0 || recurseTimes > ctx.depth && ctx.depth !== null) {
return ctx.stylize(base, "regexp");
}
} else if (proxyDetails === null && isDate2(value) || proxyDetails !== null && isDate2(proxyDetails[0])) {
const date = proxyDetails?.[0] ?? value;
if (NumberIsNaN(DatePrototypeGetTime(date))) {
return ctx.stylize("Invalid Date", "date");
} else {
base = DatePrototypeToISOString(date);
if (keys.length === 0 && protoProps === void 0) {
return ctx.stylize(base, "date");
}
}
} else if (proxyDetails === null && typeof globalThis.Temporal !== "undefined" && (ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.Instant.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.ZonedDateTime.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.PlainDate.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.PlainTime.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.PlainDateTime.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.PlainYearMonth.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.PlainMonthDay.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.Duration.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.TimeZone.prototype,
value
) || ObjectPrototypeIsPrototypeOf(
globalThis.Temporal.Calendar.prototype,
value
))) {
return ctx.stylize(value.toString(), "temporal");
} else if (proxyDetails === null && (isNativeError2(value) || ObjectPrototypeIsPrototypeOf(ErrorPrototype, value)) || proxyDetails !== null && (isNativeError2(proxyDetails[0]) || ObjectPrototypeIsPrototypeOf(ErrorPrototype, proxyDetails[0]))) {
const error = proxyDetails?.[0] ?? value;
base = inspectError(error, ctx);
if (keys.length === 0 && protoProps === void 0) {
return base;
}
} else if (isAnyArrayBuffer2(value)) {
const arrayType = isArrayBuffer2(value) ? "ArrayBuffer" : "SharedArrayBuffer";
const prefix = getPrefix(constructor, tag, arrayType);
if (typedArray === void 0) {
formatter = formatArrayBuffer;
} else if (keys.length === 0 && protoProps === void 0) {
return prefix + `{ byteLength: ${formatNumber(
ctx.stylize,
TypedArrayPrototypeGetByteLength(value)
)} }`;
}
braces[0] = `${prefix}{`;
ArrayPrototypeUnshift(keys, "byteLength");
} else if (isDataView2(value)) {
braces[0] = `${getPrefix(constructor, tag, "DataView")}{`;
ArrayPrototypeUnshift(keys, "byteLength", "byteOffset", "buffer");
} else if (isPromise2(value)) {
braces[0] = `${getPrefix(constructor, tag, "Promise")}{`;
formatter = formatPromise;
} else if (isWeakSet2(value)) {
braces[0] = `${getPrefix(constructor, tag, "WeakSet")}{`;
formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection;
} else if (isWeakMap2(value)) {
braces[0] = `${getPrefix(constructor, tag, "WeakMap")}{`;
formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
} else if (isModuleNamespaceObject2(value)) {
braces[0] = `${getPrefix(constructor, tag, "Module")}{`;
formatter = FunctionPrototypeBind(formatNamespaceObject, null, keys);
} else if (isBoxedPrimitive2(value)) {
base = getBoxedBase(value, ctx, keys, constructor, tag);
if (keys.length === 0 && protoProps === void 0) {
return base;
}
} else {
if (keys.length === 0 && protoProps === void 0) {
return `${getCtxStyle(value, constructor, tag)}{}`;
}
braces[0] = `${getCtxStyle(value, constructor, tag)}{`;
}
}
}
if (recurseTimes > ctx.depth && ctx.depth !== null) {
let constructorName = StringPrototypeSlice(
getCtxStyle(value, constructor, tag),
0,
-1
);
if (constructor !== null) {
constructorName = `[${constructorName}]`;
}
return ctx.stylize(constructorName, "special");
}
recurseTimes += 1;
ArrayPrototypePush(ctx.seen, value);
ctx.currentDepth = recurseTimes;
let output;
try {
output = formatter(ctx, value, recurseTimes);
for (i = 0; i < keys.length; i++) {
ArrayPrototypePush(
output,
formatProperty(ctx, value, recurseTimes, keys[i], extrasType)
);
}
if (protoProps !== void 0) {
ArrayPrototypePushApply(output, protoProps);
}
} catch (error) {
return ctx.stylize(
`[Internal Formatting Error] ${error.stack}`,
"internalError"
);
}
if (ctx.circular !== void 0) {
const index = ctx.circular.get(value);
if (index !== void 0) {
const reference = ctx.stylize(`<ref *${index}>`, "special");
if (ctx.compact !== true) {
base = base === "" ? reference : `${reference} ${base}`;
} else {
braces[0] = `${reference} ${braces[0]}`;
}
}
}
ArrayPrototypePop(ctx.seen);
if (ctx.sorted) {
const comparator = ctx.sorted === true ? void 0 : ctx.sorted;
if (extrasType === kObjectType) {
output = ArrayPrototypeSort(output, comparator);
} else if (keys.length > 1) {
const sorted = ArrayPrototypeSort(
ArrayPrototypeSlice(output, output.length - keys.length),
comparator
);
ArrayPrototypeSplice(
output,
output.length - keys.length,
keys.length,
...new SafeArrayIterator(sorted)
);
}
}
const res = reduceToSingleString(
ctx,
output,
base,
braces,
extrasType,
recurseTimes,
value
);
const budget = ctx.budget[ctx.indentationLvl] || 0;
const newLength = budget + res.length;
ctx.budget[ctx.indentationLvl] = newLength;
if (newLength > 2 ** 27) {
ctx.depth = -1;
}
return res;
}
const builtInObjectsRegExp = new SafeRegExp("^[A-Z][a-zA-Z0-9]+$");
const builtInObjects = new SafeSet(
ArrayPrototypeFilter(
ObjectGetOwnPropertyNames(globalThis),
(e) => RegExpPrototypeTest(builtInObjectsRegExp, e)
)
);
function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
let depth = 0;
let keys;
let keySet;
do {
if (depth !== 0 || main === obj) {
obj = ObjectGetPrototypeOf(obj);
if (obj === null) {
return;
}
const descriptor = ObjectGetOwnPropertyDescriptor(obj, "constructor");
if (descriptor !== void 0 && typeof descriptor.value === "function" && SetPrototypeHas(builtInObjects, descriptor.value.name)) {
return;
}
}
if (depth === 0) {
keySet = new SafeSet();
} else {
ArrayPrototypeForEach(keys, (key) => SetPrototypeAdd(keySet, key));
}
keys = ReflectOwnKeys(obj);
ArrayPrototypePush(ctx.seen, main);
for (const key of new SafeArrayIterator(keys)) {
if (key === "constructor" || ObjectHasOwn(main, key) || depth !== 0 && SetPrototypeHas(keySet, key)) {
continue;
}
const desc = ObjectGetOwnPropertyDescriptor(obj, key);
if (typeof desc.value === "function") {
continue;
}
const value = formatProperty(
ctx,
obj,
recurseTimes,
key,
kObjectType,
desc,
main
);
if (ctx.colors) {
ArrayPrototypePush(output, `\x1B[2m${value}\x1B[22m`);
} else {
ArrayPrototypePush(output, value);
}
}
ArrayPrototypePop(ctx.seen);
} while (++depth !== 3);
}
function isInstanceof(proto, object) {
try {
return ObjectPrototypeIsPrototypeOf(proto, object);
} catch {
return false;
}
}
function getConstructorName(obj, ctx, recurseTimes, protoProps) {
let firstProto;
const tmp = obj;
while (obj || isUndetectableObject(obj)) {
let descriptor;
try {
descriptor = ObjectGetOwnPropertyDescriptor(obj, "constructor");
} catch {
}
if (descriptor !== void 0 && typeof descriptor.value === "function" && descriptor.value.name !== "" && isInstanceof(descriptor.value.prototype, tmp)) {
if (protoProps !== void 0 && (firstProto !== obj || !SetPrototypeHas(builtInObjects, descriptor.value.name))) {
addPrototypeProperties(
ctx,
tmp,
firstProto || tmp,
recurseTimes,
protoProps
);
}
return String2(descriptor.value.name);
}
obj = ObjectGetPrototypeOf(obj);
if (firstProto === void 0) {
firstProto = obj;
}
}
if (firstProto === null) {
return null;
}
const res = op_get_constructor_name(tmp);
if (recurseTimes > ctx.depth && ctx.depth !== null) {
return `${res} <Complex prototype>`;
}
const protoConstr = getConstructorName(
firstProto,
ctx,
recurseTimes + 1,
protoProps
);
if (protoConstr === null) {
return `${res} <${inspect(firstProto, {
...ctx,
customInspect: false,
depth: -1
})}>`;
}
return `${res} <${protoConstr}>`;
}
const formatPrimitiveRegExp = new SafeRegExp("(?<=\n)");
function formatPrimitive(fn, value, ctx) {
if (typeof value === "string") {
let trailer = "";
if (value.length > ctx.maxStringLength) {
const remaining = value.length - ctx.maxStringLength;
value = StringPrototypeSlice(value, 0, ctx.maxStringLength);
trailer = `... ${remaining} more character${remaining > 1 ? "s" : ""}`;
}
if (ctx.compact !== true && value.length > kMinLineLength && value.length > ctx.breakLength - ctx.indentationLvl - 4) {
return ArrayPrototypeJoin(
ArrayPrototypeMap(
StringPrototypeSplit(value, formatPrimitiveRegExp),
(line) => fn(quoteString(line, ctx), "string")
),
` +
${StringPrototypeRepeat(" ", ctx.indentationLvl + 2)}`
) + trailer;
}
return fn(quoteString(value, ctx), "string") + trailer;
}
if (typeof value === "number") {
return formatNumber(fn, value);
}
if (typeof value === "bigint") {
return formatBigInt(fn, value);
}
if (typeof value === "boolean") {
return fn(`${value}`, "boolean");
}
if (typeof value === "undefined") {
return fn("undefined", "undefined");
}
return fn(maybeQuoteSymbol(value, ctx), "symbol");
}
function getPrefix(constructor, tag, fallback, size = "") {
if (constructor === null) {
if (tag !== "" && fallback !== tag) {
return `[${fallback}${size}: null prototype] [${tag}] `;
}
return `[${fallback}${size}: null prototype] `;
}
if (tag !== "" && constructor !== tag) {
return `${constructor}${size} [${tag}] `;
}
return `${constructor}${size} `;
}
function formatArray(ctx, value, recurseTimes) {
const valLen = value.length;
const len = MathMin(MathMax(0, ctx.maxArrayLength), valLen);
const remaining = valLen - len;
const output = [];
for (let i = 0; i < len; i++) {
ArrayPrototypePush(
output,
formatProperty(ctx, value, recurseTimes, i, kArrayType)
);
}
if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
return output;
}
function getCtxStyle(value, constructor, tag) {
let fallback = "";
if (constructor === null) {
fallback = op_get_constructor_name(value);
if (fallback === tag) {
fallback = "Object";
}
}
return getPrefix(constructor, tag, fallback);
}
function getKeys(value, showHidden) {
let keys;
const symbols = ObjectGetOwnPropertySymbols(value);
if (showHidden) {
keys = ObjectGetOwnPropertyNames(value);
if (symbols.length !== 0) {
ArrayPrototypePushApply(keys, symbols);
}
} else {
try {
keys = ObjectKeys(value);
} catch (err) {
assert(
isNativeError2(err) && err.name === "ReferenceError" && isModuleNamespaceObject2(value)
);
keys = ObjectGetOwnPropertyNames(value);
}
if (symbols.length !== 0) {
const filter = (key) => ObjectPrototypePropertyIsEnumerable(value, key);
ArrayPrototypePushApply(keys, ArrayPrototypeFilter(symbols, filter));
}
}
return keys;
}
function formatSet(value, ctx, _ignored, recurseTimes) {
ctx.indentationLvl += 2;
const values = [...new SafeSetIterator(value)];
const valLen = SetPrototypeGetSize(value);
const len = MathMin(MathMax(0, ctx.iterableLimit), valLen);
const remaining = valLen - len;
const output = [];
for (let i = 0; i < len; i++) {
ArrayPrototypePush(output, formatValue(ctx, values[i], recurseTimes));
}
if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
ctx.indentationLvl -= 2;
return output;
}
function formatMap(value, ctx, _ignored, recurseTimes) {
ctx.indentationLvl += 2;
const values = [...new SafeMapIterator(value)];
const valLen = MapPrototypeGetSize(value);
const len = MathMin(MathMax(0, ctx.iterableLimit), valLen);
const remaining = valLen - len;
const output = [];
for (let i = 0; i < len; i++) {
ArrayPrototypePush(
output,
`${formatValue(ctx, values[i][0], recurseTimes)} => ${formatValue(
ctx,
values[i][1],
recurseTimes
)}`
);
}
if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
ctx.indentationLvl -= 2;
return output;
}
function formatTypedArray(value, length, ctx, _ignored, recurseTimes) {
const maxLength = MathMin(MathMax(0, ctx.maxArrayLength), length);
const remaining = value.length - maxLength;
const output = [];
const elementFormatter = value.length > 0 && typeof value[0] === "number" ? formatNumber : formatBigInt;
for (let i = 0; i < maxLength; ++i) {
output[i] = elementFormatter(ctx.stylize, value[i]);
}
if (remaining > 0) {
output[maxLength] = `... ${remaining} more item${remaining > 1 ? "s" : ""}`;
}
if (ctx.showHidden) {
ctx.indentationLvl += 2;
for (const key of new SafeArrayIterator([
"BYTES_PER_ELEMENT",
"length",
"byteLength",
"byteOffset",
"buffer"
])) {
const str = formatValue(ctx, value[key], recurseTimes, true);
ArrayPrototypePush(output, `[${key}]: ${str}`);
}
ctx.indentationLvl -= 2;
}
return output;
}
function getIteratorBraces(type, tag) {
if (tag !== `${type} Iterator`) {
if (tag !== "") {
tag += "] [";
}
tag += `${type} Iterator`;
}
return [`[${tag}] {`, "}"];
}
const iteratorRegExp = new SafeRegExp(" Iterator] {$");
function formatIterator(braces, ctx, value, recurseTimes) {
const { 0: entries, 1: isKeyValue } = op_preview_entries(value, true);
if (isKeyValue) {
braces[0] = StringPrototypeReplace(
braces[0],
iteratorRegExp,
" Entries] {"
);
return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);
}
return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
}
function handleCircular(value, ctx) {
let index = 1;
if (ctx.circular === void 0) {
ctx.circular = new SafeMap();
MapPrototypeSet(ctx.circular, value, index);
} else {
index = MapPrototypeGet(ctx.circular, value);
if (index === void 0) {
index = MapPrototypeGetSize(ctx.circular) + 1;
MapPrototypeSet(ctx.circular, value, index);
}
}
return ctx.stylize(`[Circular *${index}]`, "special");
}
const AGGREGATE_ERROR_HAS_AT_PATTERN = new SafeRegExp(/\s+at/);
const AGGREGATE_ERROR_NOT_EMPTY_LINE_PATTERN = new SafeRegExp(/^(?!\s*$)/gm);
function inspectError(value, ctx) {
const causes = [value];
let err = value;
while (err.cause) {
if (ArrayPrototypeIncludes(causes, err.cause)) {
ArrayPrototypePush(causes, handleCircular(err.cause, ctx));
break;
} else {
ArrayPrototypePush(causes, err.cause);
err = err.cause;
}
}
const refMap = new SafeMap();
for (let i = 0; i < causes.length; ++i) {
const cause = causes[i];
if (ctx.circular !== void 0) {
const index = MapPrototypeGet(ctx.circular, cause);
if (index !== void 0) {
MapPrototypeSet(
refMap,
cause,
ctx.stylize(`<ref *${index}> `, "special")
);
}
}
}
ArrayPrototypeShift(causes);
let finalMessage = MapPrototypeGet(refMap, value) ?? "";
if (isAggregateError(value)) {
const stackLines = StringPrototypeSplit(value.stack, "\n");
while (true) {
const line = ArrayPrototypeShift(stackLines);
if (RegExpPrototypeTest(AGGREGATE_ERROR_HAS_AT_PATTERN, line)) {
ArrayPrototypeUnshift(stackLines, line);
break;
} else if (typeof line === "undefined") {
break;
}
finalMessage += line;
finalMessage += "\n";
}
const aggregateMessage = ArrayPrototypeJoin(
ArrayPrototypeMap(
value.errors,
(error) => StringPrototypeReplace(
inspectArgs([error]),
AGGREGATE_ERROR_NOT_EMPTY_LINE_PATTERN,
StringPrototypeRepeat(" ", 4)
)
),
"\n"
);
finalMessage += aggregateMessage;
finalMessage += "\n";
finalMessage += ArrayPrototypeJoin(stackLines, "\n");
} else {
const stack = value.stack;
if (stack?.includes("\n at")) {
finalMessage += stack;
} else {
finalMessage += `[${stack || ErrorPrototypeToString(value)}]`;
}
}
finalMessage += ArrayPrototypeJoin(
ArrayPrototypeMap(
causes,
(cause) => "\nCaused by " + (MapPrototypeGet(refMap, cause) ?? "") + (cause?.stack ?? cause)
),
""
);
return finalMessage;
}
const hexSliceLookupTable = function() {
const alphabet = "0123456789abcdef";
const table = [];
for (let i = 0; i < 16; ++i) {
const i16 = i * 16;
for (let j = 0; j < 16; ++j) {
table[i16 + j] = alphabet[i] + alphabet[j];
}
}
return table;
}();
function hexSlice(buf, start, end) {
const len = TypedArrayPrototypeGetLength(buf);
if (!start || start < 0) {
start = 0;
}
if (!end || end < 0 || end > len) {
end = len;
}
let out = "";
for (let i = start; i < end; ++i) {
out += hexSliceLookupTable[buf[i]];
}
return out;
}
const arrayBufferRegExp = new SafeRegExp("(.{2})", "g");
function formatArrayBuffer(ctx, value) {
let valLen;
try {
valLen = ArrayBufferPrototypeGetByteLength(value);
} catch {
valLen = getSharedArrayBufferByteLength(value);
}
const len = MathMin(MathMax(0, ctx.maxArrayLength), valLen);
let buffer;
try {
buffer = new Uint8Array2(value, 0, len);
} catch {
return [ctx.stylize("(detached)", "special")];
}
let str = StringPrototypeTrim(
StringPrototypeReplace(hexSlice(buffer), arrayBufferRegExp, "$1 ")
);
const remaining = valLen - len;
if (remaining > 0) {
str += ` ... ${remaining} more byte${remaining > 1 ? "s" : ""}`;
}
return [`${ctx.stylize("[Uint8Contents]", "special")}: <${str}>`];
}
function formatNumber(fn, value) {
return fn(ObjectIs(value, -0) ? "-0" : `${value}`, "number");
}
const PromiseState = {
Pending: 0,
Fulfilled: 1,
Rejected: 2
};
function formatPromise(ctx, value, recurseTimes) {
let output;
const { 0: state, 1: result } = core.getPromiseDetails(value);
if (state === PromiseState.Pending) {
output = [ctx.stylize("<pending>", "special")];
} else {
ctx.indentationLvl += 2;
const str = formatValue(ctx, result, recurseTimes);
ctx.indentationLvl -= 2;
output = [
state === PromiseState.Rejected ? `${ctx.stylize("<rejected>", "special")} ${str}` : str
];
}
return output;
}
function formatWeakCollection(ctx) {
return [ctx.stylize("<items unknown>", "special")];
}
function formatWeakSet(ctx, value, recurseTimes) {
const entries = op_preview_entries(value, false);
return formatSetIterInner(ctx, recurseTimes, entries, kWeak);
}
function formatWeakMap(ctx, value, recurseTimes) {
const entries = op_preview_entries(value, false);
return formatMapIterInner(ctx, recurseTimes, entries, kWeak);
}
function formatProperty(ctx, value, recurseTimes, key, type, desc, original = value) {
let name, str;
let extra = " ";
desc = desc || ObjectGetOwnPropertyDescriptor(value, key) || {
value: value[key],
enumerable: true
};
if (desc.value !== void 0) {
const diff = ctx.compact !== true || type !== kObjectType ? 2 : 3;
ctx.indentationLvl += diff;
str = formatValue(ctx, desc.value, recurseTimes);
if (diff === 3 && ctx.breakLength < getStringWidth(str, ctx.colors)) {
extra = `
${StringPrototypeRepeat(" ", ctx.indentationLvl)}`;
}
ctx.indentationLvl -= diff;
} else if (desc.get !== void 0) {
const label = desc.set !== void 0 ? "Getter/Setter" : "Getter";
const s = ctx.stylize;
const sp = "special";
if (ctx.getters && (ctx.getters === true || ctx.getters === "get" && desc.set === void 0 || ctx.getters === "set" && desc.set !== void 0)) {
try {
const tmp = FunctionPrototypeCall(desc.get, original);
ctx.indentationLvl += 2;
if (tmp === null) {
str = `${s(`[${label}:`, sp)} ${s("null", "null")}${s("]", sp)}`;
} else if (typeof tmp === "object") {
str = `${s(`[${label}]`, sp)} ${formatValue(
ctx,
tmp,
recurseTimes
)}`;
} else {
const primitive = formatPrimitive(s, tmp, ctx);
str = `${s(`[${label}:`, sp)} ${primitive}${s("]", sp)}`;
}
ctx.indentationLvl -= 2;
} catch (err) {
const message = `<Inspection threw (${err.message})>`;
str = `${s(`[${label}:`, sp)} ${message}${s("]", sp)}`;
}
} else {
str = ctx.stylize(`[${label}]`, sp);
}
} else if (desc.set !== void 0) {
str = ctx.stylize("[Setter]", "special");
} else {
str = ctx.stylize("undefined", "undefined");
}
if (type === kArrayType) {
return str;
}
if (typeof key === "symbol") {
name = `[${ctx.stylize(maybeQuoteSymbol(key, ctx), "symbol")}]`;
} else if (key === "__proto__") {
name = "['__proto__']";
} else if (desc.enumerable === false) {
const tmp = StringPrototypeReplace(
key,
strEscapeSequencesReplacer,
escapeFn
);
name = `[${tmp}]`;
} else if (keyStrRegExp.test(key)) {
name = ctx.stylize(key, "name");
} else {
name = ctx.stylize(quoteString(key, ctx), "string");
}
return `${name}:${extra}${str}`;
}
const colorRegExp = new SafeRegExp("\x1B\\[\\d\\d?m", "g");
function removeColors(str) {
return StringPrototypeReplace(str, colorRegExp, "");
}
function isBelowBreakLength(ctx, output, start, base) {
let totalLength = output.length + start;
if (totalLength + output.length > ctx.breakLength) {
return false;
}
for (let i = 0; i < output.length; i++) {
if (ctx.colors) {
totalLength += removeColors(output[i]).length;
} else {
totalLength += output[i].length;
}
if (totalLength > ctx.breakLength) {
return false;
}
}
return base === "" || !StringPrototypeIncludes(base, "\n");
}
function formatBigInt(fn, value) {
return fn(`${value}n`, "bigint");
}
function formatNamespaceObject(keys, ctx, value, recurseTimes) {
const output = [];
for (let i = 0; i < keys.length; i++) {
try {
output[i] = formatProperty(
ctx,
value,
recurseTimes,
keys[i],
kObjectType
);
} catch (_err) {
const tmp = { [keys[i]]: "" };
output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);
const pos = StringPrototypeLastIndexOf(output[i], " ");
output[i] = StringPrototypeSlice(output[i], 0, pos + 1) + ctx.stylize("<uninitialized>", "special");
}
}
keys.length = 0;
return output;
}
function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
const keys = ObjectKeys(value);
let index = i;
for (; i < keys.length && output.length < maxLength; i++) {
const key = keys[i];
const tmp = +key;
if (tmp > 2 ** 32 - 2) {
break;
}
if (`${index}` !== key) {
if (!numberRegExp.test(key)) {
break;
}
const emptyItems = tmp - index;
const ending = emptyItems > 1 ? "s" : "";
const message = `<${emptyItems} empty item${ending}>`;
ArrayPrototypePush(output, ctx.stylize(message, "undefined"));
index = tmp;
if (output.length === maxLength) {
break;
}
}
ArrayPrototypePush(
output,
formatProperty(ctx, value, recurseTimes, key, kArrayType)
);
index++;
}
const remaining = value.length - index;
if (output.length !== maxLength) {
if (remaining > 0) {
const ending = remaining > 1 ? "s" : "";
const message = `<${remaining} empty item${ending}>`;
ArrayPrototypePush(output, ctx.stylize(message, "undefined"));
}
} else if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
return output;
}
function getBoxedBase(value, ctx, keys, constructor, tag) {
let type, primitive;
if (isNumberObject2(value)) {
type = "Number";
primitive = NumberPrototypeValueOf(value);
} else if (isStringObject2(value)) {
type = "String";
primitive = StringPrototypeValueOf(value);
ArrayPrototypeSplice(keys, 0, value.length);
} else if (isBooleanObject2(value)) {
type = "Boolean";
primitive = BooleanPrototypeValueOf(value);
} else if (isBigIntObject2(value)) {
type = "BigInt";
primitive = BigIntPrototypeValueOf(value);
} else {
type = "Symbol";
primitive = SymbolPrototypeValueOf(value);
}
let base = `[${type}`;
if (type !== constructor) {
if (constructor === null) {
base += " (null prototype)";
} else {
base += ` (${constructor})`;
}
}
base += `: ${formatPrimitive(stylizeNoColor, primitive, ctx)}]`;
if (tag !== "" && tag !== constructor) {
base += ` [${tag}]`;
}
if (keys.length !== 0 || ctx.stylize === stylizeNoColor) {
return base;
}
return ctx.stylize(base, StringPrototypeToLowerCase(type));
}
function reduceToSingleString(ctx, output, base, braces, extrasType, recurseTimes, value) {
if (ctx.compact !== true) {
if (typeof ctx.compact === "number" && ctx.compact >= 1) {
const entries = output.length;
if (extrasType === kArrayExtrasType && entries > 6) {
output = groupArrayElements(ctx, output, value);
}
if (ctx.currentDepth - recurseTimes < ctx.compact && entries === output.length) {
const start = output.length + ctx.indentationLvl + braces[0].length + base.length + 10;
if (isBelowBreakLength(ctx, output, start, base)) {
const joinedOutput = ArrayPrototypeJoin(output, ", ");
if (!StringPrototypeIncludes(joinedOutput, "\n")) {
return `${base ? `${base} ` : ""}${braces[0]} ${joinedOutput} ${braces[1]}`;
}
}
}
}
const indentation2 = `
${StringPrototypeRepeat(" ", ctx.indentationLvl)}`;
return `${base ? `${base} ` : ""}${braces[0]}${indentation2} ${ArrayPrototypeJoin(output, `,${indentation2} `)}${ctx.trailingComma ? "," : ""}${indentation2}${braces[1]}`;
}
if (isBelowBreakLength(ctx, output, 0, base)) {
return `${braces[0]}${base ? ` ${base}` : ""} ${ArrayPrototypeJoin(
output,
", "
)} ` + braces[1];
}
const indentation = StringPrototypeRepeat(" ", ctx.indentationLvl);
const ln = base === "" && braces[0].length === 1 ? " " : `${base ? ` ${base}` : ""}
${indentation} `;
return `${braces[0]}${ln}${ArrayPrototypeJoin(
output,
`,
${indentation} `
)} ${braces[1]}`;
}
function groupArrayElements(ctx, output, value) {
let totalLength = 0;
let maxLength = 0;
let i = 0;
let outputLength = output.length;
if (ctx.maxArrayLength < output.length) {
outputLength--;
}
const separatorSpace = 2;
const dataLen = [];
for (; i < outputLength; i++) {
const len = getStringWidth(output[i], ctx.colors);
dataLen[i] = len;
totalLength += len + separatorSpace;
if (maxLength < len) {
maxLength = len;
}
}
const actualMax = maxLength + separatorSpace;
if (actualMax * 3 + ctx.indentationLvl < ctx.breakLength && (totalLength / actualMax > 5 || maxLength <= 6)) {
const approxCharHeights = 2.5;
const averageBias = MathSqrt(actualMax - totalLength / output.length);
const biasedMax = MathMax(actualMax - 3 - averageBias, 1);
const columns = MathMin(
MathRound(
MathSqrt(approxCharHeights * biasedMax * outputLength) / biasedMax
),
MathFloor((ctx.breakLength - ctx.indentationLvl) / actualMax),
ctx.compact * 4,
15
);
if (columns <= 1) {
return output;
}
const tmp = [];
const maxLineLength = [];
for (let i2 = 0; i2 < columns; i2++) {
let lineMaxLength = 0;
for (let j = i2; j < output.length; j += columns) {
if (dataLen[j] > lineMaxLength) {
lineMaxLength = dataLen[j];
}
}
lineMaxLength += separatorSpace;
maxLineLength[i2] = lineMaxLength;
}
let order = StringPrototypePadStart;
if (value !== void 0) {
for (let i2 = 0; i2 < output.length; i2++) {
if (typeof value[i2] !== "number" && typeof value[i2] !== "bigint") {
order = StringPrototypePadEnd;
break;
}
}
}
for (let i2 = 0; i2 < outputLength; i2 += columns) {
const max = MathMin(i2 + columns, outputLength);
let str = "";
let j = i2;
for (; j < max - 1; j++) {
const padding = maxLineLength[j - i2] + output[j].length - dataLen[j];
str += order(`${output[j]}, `, padding, " ");
}
if (order === StringPrototypePadStart) {
const padding = maxLineLength[j - i2] + output[j].length - dataLen[j] - separatorSpace;
str += StringPrototypePadStart(output[j], padding, " ");
} else {
str += output[j];
}
ArrayPrototypePush(tmp, str);
}
if (ctx.maxArrayLength < output.length) {
ArrayPrototypePush(tmp, output[outputLength]);
}
output = tmp;
}
return output;
}
function formatMapIterInner(ctx, recurseTimes, entries, state) {
const maxArrayLength = MathMax(ctx.maxArrayLength, 0);
const len = entries.length / 2;
const remaining = len - maxArrayLength;
const maxLength = MathMin(maxArrayLength, len);
const output = [];
let i = 0;
ctx.indentationLvl += 2;
if (state === kWeak) {
for (; i < maxLength; i++) {
const pos = i * 2;
output[i] = `${formatValue(
ctx,
entries[pos],
recurseTimes
)} => ${formatValue(ctx, entries[pos + 1], recurseTimes)}`;
}
if (!ctx.sorted) {
ArrayPrototypeSort(output);
}
} else {
for (; i < maxLength; i++) {
const pos = i * 2;
const res = [
formatValue(ctx, entries[pos], recurseTimes),
formatValue(ctx, entries[pos + 1], recurseTimes)
];
output[i] = reduceToSingleString(
ctx,
res,
"",
["[", "]"],
kArrayExtrasType,
recurseTimes
);
}
}
ctx.indentationLvl -= 2;
if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
return output;
}
function formatSetIterInner(ctx, recurseTimes, entries, state) {
const maxArrayLength = MathMax(ctx.maxArrayLength, 0);
const maxLength = MathMin(maxArrayLength, entries.length);
const output = [];
ctx.indentationLvl += 2;
for (let i = 0; i < maxLength; i++) {
output[i] = formatValue(ctx, entries[i], recurseTimes);
}
ctx.indentationLvl -= 2;
if (state === kWeak && !ctx.sorted) {
ArrayPrototypeSort(output);
}
const remaining = entries.length - maxLength;
if (remaining > 0) {
ArrayPrototypePush(
output,
`... ${remaining} more item${remaining > 1 ? "s" : ""}`
);
}
return output;
}
const ansiPattern = "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))";
const ansi = new SafeRegExp(ansiPattern, "g");
function getStringWidth(str, removeControlChars = true) {
let width = 0;
if (removeControlChars) {
str = stripVTControlCharacters(str);
}
str = StringPrototypeNormalize(str, "NFC");
for (const char of new SafeStringIterator(str)) {
const code = StringPrototypeCodePointAt(char, 0);
if (isFullWidthCodePoint(code)) {
width += 2;
} else if (!isZeroWidthCodePoint(code)) {
width++;
}
}
return width;
}
const isZeroWidthCodePoint = (code) => {
return code <= 31 || code >= 127 && code <= 159 || code >= 768 && code <= 879 || code >= 8203 && code <= 8207 || code >= 8400 && code <= 8447 || code >= 65024 && code <= 65039 || code >= 65056 && code <= 65071 || code >= 917760 && code <= 917999;
};
function stripVTControlCharacters(str) {
return StringPrototypeReplace(str, ansi, "");
}
function hasOwnProperty(obj, v) {
if (obj == null) {
return false;
}
return ObjectHasOwn(obj, v);
}
const tableChars = {
middleMiddle: "\u2500",
rowMiddle: "\u253C",
topRight: "\u2510",
topLeft: "\u250C",
leftMiddle: "\u251C",
topMiddle: "\u252C",
bottomRight: "\u2518",
bottomLeft: "\u2514",
bottomMiddle: "\u2534",
rightMiddle: "\u2524",
left: "\u2502 ",
right: " \u2502",
middle: " \u2502 "
};
function isFullWidthCodePoint(code) {
return code >= 4352 && (code <= 4447 || code === 9001 || code === 9002 || code >= 11904 && code <= 12871 && code !== 12351 || code >= 12880 && code <= 19903 || code >= 19968 && code <= 42182 || code >= 43360 && code <= 43388 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65049 || code >= 65072 && code <= 65131 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 110592 && code <= 110593 || code >= 127488 && code <= 127569 || code >= 127744 && code <= 128591 || code >= 131072 && code <= 262141);
}
function renderRow(row, columnWidths, columnRightAlign) {
let out = tableChars.left;
for (let i = 0; i < row.length; i++) {
const cell = row[i];
const len = getStringWidth(cell);
const padding = StringPrototypeRepeat(" ", columnWidths[i] - len);
if (columnRightAlign?.[i]) {
out += `${padding}${cell}`;
} else {
out += `${cell}${padding}`;
}
if (i !== row.length - 1) {
out += tableChars.middle;
}
}
out += tableChars.right;
return out;
}
function cliTable(head, columns) {
const rows = [];
const columnWidths = ArrayPrototypeMap(head, (h) => getStringWidth(h));
const longestColumn = ArrayPrototypeReduce(
columns,
(n, a) => MathMax(n, a.length),
0
);
const columnRightAlign = ArrayPrototypeFill(
new Array2(columnWidths.length),
true
);
for (let i = 0; i < head.length; i++) {
const column = columns[i];
for (let j = 0; j < longestColumn; j++) {
if (rows[j] === void 0) {
rows[j] = [];
}
const value = rows[j][i] = hasOwnProperty(column, j) ? column[j] : "";
const width = columnWidths[i] || 0;
const counted = getStringWidth(value);
columnWidths[i] = MathMax(width, counted);
columnRightAlign[i] &= NumberIsInteger(+value);
}
}
const divider = ArrayPrototypeMap(
columnWidths,
(i) => StringPrototypeRepeat(tableChars.middleMiddle, i + 2)
);
let result = `${tableChars.topLeft}${ArrayPrototypeJoin(
divider,
tableChars.topMiddle
)}${tableChars.topRight}
${renderRow(head, columnWidths)}
${tableChars.leftMiddle}${ArrayPrototypeJoin(
divider,
tableChars.rowMiddle
)}${tableChars.rightMiddle}
`;
for (let i = 0; i < rows.length; ++i) {
const row = rows[i];
result += `${renderRow(row, columnWidths, columnRightAlign)}
`;
}
result += `${tableChars.bottomLeft}${ArrayPrototypeJoin(
divider,
tableChars.bottomMiddle
)}` + tableChars.bottomRight;
return result;
}
const denoInspectDefaultOptions = {
indentationLvl: 0,
currentDepth: 0,
stylize: stylizeNoColor,
showHidden: false,
depth: 4,
colors: false,
showProxy: false,
breakLength: 80,
escapeSequences: true,
compact: 3,
sorted: false,
getters: false,
maxArrayLength: 100,
maxStringLength: 1e4,
customInspect: true,
quotes: ['"', "'", "`"],
iterableLimit: 100,
trailingComma: false,
inspect,
indentLevel: 0
};
function getDefaultInspectOptions() {
return {
budget: {},
seen: [],
...denoInspectDefaultOptions
};
}
const DEFAULT_INDENT = " ";
const STR_ABBREVIATE_SIZE = 1e4;
class CSI {
static kClear = "\x1B[1;1H";
static kClearScreenDown = "\x1B[0J";
}
const QUOTE_SYMBOL_REG = new SafeRegExp(/^[a-zA-Z_][a-zA-Z_.0-9]*$/);
function maybeQuoteSymbol(symbol, ctx) {
const description = SymbolPrototypeGetDescription(symbol);
if (description === void 0) {
return SymbolPrototypeToString(symbol);
}
if (RegExpPrototypeTest(QUOTE_SYMBOL_REG, description)) {
return SymbolPrototypeToString(symbol);
}
return `Symbol(${quoteString(description, ctx)})`;
}
function quoteString(string, ctx) {
const quote = ArrayPrototypeFind(
ctx.quotes,
(c) => !StringPrototypeIncludes(string, c)
) ?? ctx.quotes[0];
const escapePattern = new SafeRegExp(`(?=[${quote}\\\\])`, "g");
string = StringPrototypeReplace(string, escapePattern, "\\");
if (ctx.escapeSequences) {
string = replaceEscapeSequences(string);
}
return `${quote}${string}${quote}`;
}
const ESCAPE_PATTERN = new SafeRegExp(/([\b\f\n\r\t\v])/g);
const ESCAPE_MAP = ObjectFreeze({
"\b": "\\b",
"\f": "\\f",
"\n": "\\n",
"\r": "\\r",
" ": "\\t",
"\v": "\\v"
});
const ESCAPE_PATTERN2 = new SafeRegExp("[\0- \x7F-\x9F]", "g");
function replaceEscapeSequences(string) {
return StringPrototypeReplace(
StringPrototypeReplace(string, ESCAPE_PATTERN, (c) => ESCAPE_MAP[c]),
ESCAPE_PATTERN2,
(c) => "\\x" + StringPrototypePadStart(
NumberPrototypeToString(StringPrototypeCharCodeAt(c, 0), 16),
2,
"0"
)
);
}
function inspectValueWithQuotes(value, ctx) {
const abbreviateSize = typeof ctx.strAbbreviateSize === "undefined" ? STR_ABBREVIATE_SIZE : ctx.strAbbreviateSize;
switch (typeof value) {
case "string": {
const trunc = value.length > abbreviateSize ? StringPrototypeSlice(value, 0, abbreviateSize) + "..." : value;
return ctx.stylize(quoteString(trunc, ctx), "string");
}
default:
return formatValue(ctx, value, 0);
}
}
const colorKeywords = new SafeMap([
["black", "#000000"],
["silver", "#c0c0c0"],
["gray", "#808080"],
["white", "#ffffff"],
["maroon", "#800000"],
["red", "#ff0000"],
["purple", "#800080"],
["fuchsia", "#ff00ff"],
["green", "#008000"],
["lime", "#00ff00"],
["olive", "#808000"],
["yellow", "#ffff00"],
["navy", "#000080"],
["blue", "#0000ff"],
["teal", "#008080"],
["aqua", "#00ffff"],
["orange", "#ffa500"],
["aliceblue", "#f0f8ff"],
["antiquewhite", "#faebd7"],
["aquamarine", "#7fffd4"],
["azure", "#f0ffff"],
["beige", "#f5f5dc"],
["bisque", "#ffe4c4"],
["blanchedalmond", "#ffebcd"],
["blueviolet", "#8a2be2"],
["brown", "#a52a2a"],
["burlywood", "#deb887"],
["cadetblue", "#5f9ea0"],
["chartreuse", "#7fff00"],
["chocolate", "#d2691e"],
["coral", "#ff7f50"],
["cornflowerblue", "#6495ed"],
["cornsilk", "#fff8dc"],
["crimson", "#dc143c"],
["cyan", "#00ffff"],
["darkblue", "#00008b"],
["darkcyan", "#008b8b"],
["darkgoldenrod", "#b8860b"],
["darkgray", "#a9a9a9"],
["darkgreen", "#006400"],
["darkgrey", "#a9a9a9"],
["darkkhaki", "#bdb76b"],
["darkmagenta", "#8b008b"],
["darkolivegreen", "#556b2f"],
["darkorange", "#ff8c00"],
["darkorchid", "#9932cc"],
["darkred", "#8b0000"],
["darksalmon", "#e9967a"],
["darkseagreen", "#8fbc8f"],
["darkslateblue", "#483d8b"],
["darkslategray", "#2f4f4f"],
["darkslategrey", "#2f4f4f"],
["darkturquoise", "#00ced1"],
["darkviolet", "#9400d3"],
["deeppink", "#ff1493"],
["deepskyblue", "#00bfff"],
["dimgray", "#696969"],
["dimgrey", "#696969"],
["dodgerblue", "#1e90ff"],
["firebrick", "#b22222"],
["floralwhite", "#fffaf0"],
["forestgreen", "#228b22"],
["gainsboro", "#dcdcdc"],
["ghostwhite", "#f8f8ff"],
["gold", "#ffd700"],
["goldenrod", "#daa520"],
["greenyellow", "#adff2f"],
["grey", "#808080"],
["honeydew", "#f0fff0"],
["hotpink", "#ff69b4"],
["indianred", "#cd5c5c"],
["indigo", "#4b0082"],
["ivory", "#fffff0"],
["khaki", "#f0e68c"],
["lavender", "#e6e6fa"],
["lavenderblush", "#fff0f5"],
["lawngreen", "#7cfc00"],
["lemonchiffon", "#fffacd"],
["lightblue", "#add8e6"],
["lightcoral", "#f08080"],
["lightcyan", "#e0ffff"],
["lightgoldenrodyellow", "#fafad2"],
["lightgray", "#d3d3d3"],
["lightgreen", "#90ee90"],
["lightgrey", "#d3d3d3"],
["lightpink", "#ffb6c1"],
["lightsalmon", "#ffa07a"],
["lightseagreen", "#20b2aa"],
["lightskyblue", "#87cefa"],
["lightslategray", "#778899"],
["lightslategrey", "#778899"],
["lightsteelblue", "#b0c4de"],
["lightyellow", "#ffffe0"],
["limegreen", "#32cd32"],
["linen", "#faf0e6"],
["magenta", "#ff00ff"],
["mediumaquamarine", "#66cdaa"],
["mediumblue", "#0000cd"],
["mediumorchid", "#ba55d3"],
["mediumpurple", "#9370db"],
["mediumseagreen", "#3cb371"],
["mediumslateblue", "#7b68ee"],
["mediumspringgreen", "#00fa9a"],
["mediumturquoise", "#48d1cc"],
["mediumvioletred", "#c71585"],
["midnightblue", "#191970"],
["mintcream", "#f5fffa"],
["mistyrose", "#ffe4e1"],
["moccasin", "#ffe4b5"],
["navajowhite", "#ffdead"],
["oldlace", "#fdf5e6"],
["olivedrab", "#6b8e23"],
["orangered", "#ff4500"],
["orchid", "#da70d6"],
["palegoldenrod", "#eee8aa"],
["palegreen", "#98fb98"],
["paleturquoise", "#afeeee"],
["palevioletred", "#db7093"],
["papayawhip", "#ffefd5"],
["peachpuff", "#ffdab9"],
["peru", "#cd853f"],
["pink", "#ffc0cb"],
["plum", "#dda0dd"],
["powderblue", "#b0e0e6"],
["rosybrown", "#bc8f8f"],
["royalblue", "#4169e1"],
["saddlebrown", "#8b4513"],
["salmon", "#fa8072"],
["sandybrown", "#f4a460"],
["seagreen", "#2e8b57"],
["seashell", "#fff5ee"],
["sienna", "#a0522d"],
["skyblue", "#87ceeb"],
["slateblue", "#6a5acd"],
["slategray", "#708090"],
["slategrey", "#708090"],
["snow", "#fffafa"],
["springgreen", "#00ff7f"],
["steelblue", "#4682b4"],
["tan", "#d2b48c"],
["thistle", "#d8bfd8"],
["tomato", "#ff6347"],
["turquoise", "#40e0d0"],
["violet", "#ee82ee"],
["wheat", "#f5deb3"],
["whitesmoke", "#f5f5f5"],
["yellowgreen", "#9acd32"],
["rebeccapurple", "#663399"]
]);
const HASH_PATTERN = new SafeRegExp(
/^#([\dA-Fa-f]{2})([\dA-Fa-f]{2})([\dA-Fa-f]{2})([\dA-Fa-f]{2})?$/
);
const SMALL_HASH_PATTERN = new SafeRegExp(
/^#([\dA-Fa-f])([\dA-Fa-f])([\dA-Fa-f])([\dA-Fa-f])?$/
);
const RGB_PATTERN = new SafeRegExp(
/^rgba?\(\s*([+\-]?\d*\.?\d+)\s*,\s*([+\-]?\d*\.?\d+)\s*,\s*([+\-]?\d*\.?\d+)\s*(,\s*([+\-]?\d*\.?\d+)\s*)?\)$/
);
const HSL_PATTERN = new SafeRegExp(
/^hsla?\(\s*([+\-]?\d*\.?\d+)\s*,\s*([+\-]?\d*\.?\d+)%\s*,\s*([+\-]?\d*\.?\d+)%\s*(,\s*([+\-]?\d*\.?\d+)\s*)?\)$/
);
function parseCssColor(colorString) {
if (colorKeywords.has(colorString)) {
colorString = colorKeywords.get(colorString);
}
const hashMatch = StringPrototypeMatch(colorString, HASH_PATTERN);
if (hashMatch != null) {
return [
NumberParseInt(hashMatch[1], 16),
NumberParseInt(hashMatch[2], 16),
NumberParseInt(hashMatch[3], 16)
];
}
const smallHashMatch = StringPrototypeMatch(colorString, SMALL_HASH_PATTERN);
if (smallHashMatch != null) {
return [
NumberParseInt(`${smallHashMatch[1]}${smallHashMatch[1]}`, 16),
NumberParseInt(`${smallHashMatch[2]}${smallHashMatch[2]}`, 16),
NumberParseInt(`${smallHashMatch[3]}${smallHashMatch[3]}`, 16)
];
}
const rgbMatch = StringPrototypeMatch(colorString, RGB_PATTERN);
if (rgbMatch != null) {
return [
MathRound(MathMax(0, MathMin(255, rgbMatch[1]))),
MathRound(MathMax(0, MathMin(255, rgbMatch[2]))),
MathRound(MathMax(0, MathMin(255, rgbMatch[3])))
];
}
const hslMatch = StringPrototypeMatch(colorString, HSL_PATTERN);
if (hslMatch != null) {
let h = Number2(hslMatch[1]) % 360;
if (h < 0) {
h += 360;
}
const s = MathMax(0, MathMin(100, hslMatch[2])) / 100;
const l = MathMax(0, MathMin(100, hslMatch[3])) / 100;
const c = (1 - MathAbs(2 * l - 1)) * s;
const x = c * (1 - MathAbs(h / 60 % 2 - 1));
const m = l - c / 2;
let r_;
let g_;
let b_;
if (h < 60) {
;
({ 0: r_, 1: g_, 2: b_ } = [c, x, 0]);
} else if (h < 120) {
;
({ 0: r_, 1: g_, 2: b_ } = [x, c, 0]);
} else if (h < 180) {
;
({ 0: r_, 1: g_, 2: b_ } = [0, c, x]);
} else if (h < 240) {
;
({ 0: r_, 1: g_, 2: b_ } = [0, x, c]);
} else if (h < 300) {
;
({ 0: r_, 1: g_, 2: b_ } = [x, 0, c]);
} else {
;
({ 0: r_, 1: g_, 2: b_ } = [c, 0, x]);
}
return [
MathRound((r_ + m) * 255),
MathRound((g_ + m) * 255),
MathRound((b_ + m) * 255)
];
}
return null;
}
function getDefaultCss() {
return {
backgroundColor: null,
color: null,
fontWeight: null,
fontStyle: null,
textDecorationColor: null,
textDecorationLine: []
};
}
const SPACE_PATTERN = new SafeRegExp(/\s+/g);
function parseCss(cssString) {
const css = getDefaultCss();
const rawEntries = [];
let inValue = false;
let currentKey = null;
let parenthesesDepth = 0;
let currentPart = "";
for (let i = 0; i < cssString.length; i++) {
const c = cssString[i];
if (c == "(") {
parenthesesDepth++;
} else if (parenthesesDepth > 0) {
if (c == ")") {
parenthesesDepth--;
}
} else if (inValue) {
if (c == ";") {
const value = StringPrototypeTrim(currentPart);
if (value != "") {
ArrayPrototypePush(rawEntries, [currentKey, value]);
}
currentKey = null;
currentPart = "";
inValue = false;
continue;
}
} else if (c == ":") {
currentKey = StringPrototypeTrim(currentPart);
currentPart = "";
inValue = true;
continue;
}
currentPart += c;
}
if (inValue && parenthesesDepth == 0) {
const value = StringPrototypeTrim(currentPart);
if (value != "") {
ArrayPrototypePush(rawEntries, [currentKey, value]);
}
currentKey = null;
currentPart = "";
}
for (let i = 0; i < rawEntries.length; ++i) {
const { 0: key, 1: value } = rawEntries[i];
if (key == "background-color") {
if (value != null) {
css.backgroundColor = value;
}
} else if (key == "color") {
if (value != null) {
css.color = value;
}
} else if (key == "font-weight") {
if (value == "bold") {
css.fontWeight = value;
}
} else if (key == "font-style") {
if (ArrayPrototypeIncludes(["italic", "oblique", "oblique 14deg"], value)) {
css.fontStyle = "italic";
}
} else if (key == "text-decoration-line") {
css.textDecorationLine = [];
const lineTypes = StringPrototypeSplit(value, SPACE_PATTERN);
for (let i2 = 0; i2 < lineTypes.length; ++i2) {
const lineType = lineTypes[i2];
if (ArrayPrototypeIncludes(
["line-through", "overline", "underline"],
lineType
)) {
ArrayPrototypePush(css.textDecorationLine, lineType);
}
}
} else if (key == "text-decoration-color") {
const color = parseCssColor(value);
if (color != null) {
css.textDecorationColor = color;
}
} else if (key == "text-decoration") {
css.textDecorationColor = null;
css.textDecorationLine = [];
const args = StringPrototypeSplit(value, SPACE_PATTERN);
for (let i2 = 0; i2 < args.length; ++i2) {
const arg = args[i2];
const maybeColor = parseCssColor(arg);
if (maybeColor != null) {
css.textDecorationColor = maybeColor;
} else if (ArrayPrototypeIncludes(
["line-through", "overline", "underline"],
arg
)) {
ArrayPrototypePush(css.textDecorationLine, arg);
}
}
}
}
return css;
}
function colorEquals(color1, color2) {
return color1?.[0] == color2?.[0] && color1?.[1] == color2?.[1] && color1?.[2] == color2?.[2];
}
function cssToAnsi(css, prevCss = null) {
prevCss = prevCss ?? getDefaultCss();
let ansi2 = "";
if (!colorEquals(css.backgroundColor, prevCss.backgroundColor)) {
if (css.backgroundColor == null) {
ansi2 += "\x1B[49m";
} else if (css.backgroundColor == "black") {
ansi2 += `\x1B[40m`;
} else if (css.backgroundColor == "red") {
ansi2 += `\x1B[41m`;
} else if (css.backgroundColor == "green") {
ansi2 += `\x1B[42m`;
} else if (css.backgroundColor == "yellow") {
ansi2 += `\x1B[43m`;
} else if (css.backgroundColor == "blue") {
ansi2 += `\x1B[44m`;
} else if (css.backgroundColor == "magenta") {
ansi2 += `\x1B[45m`;
} else if (css.backgroundColor == "cyan") {
ansi2 += `\x1B[46m`;
} else if (css.backgroundColor == "white") {
ansi2 += `\x1B[47m`;
} else {
if (ArrayIsArray(css.backgroundColor)) {
const { 0: r, 1: g, 2: b } = css.backgroundColor;
ansi2 += `\x1B[48;2;${r};${g};${b}m`;
} else {
const parsed = parseCssColor(css.backgroundColor);
if (parsed !== null) {
const { 0: r, 1: g, 2: b } = parsed;
ansi2 += `\x1B[48;2;${r};${g};${b}m`;
} else {
ansi2 += "\x1B[49m";
}
}
}
}
if (!colorEquals(css.color, prevCss.color)) {
if (css.color == null) {
ansi2 += "\x1B[39m";
} else if (css.color == "black") {
ansi2 += `\x1B[30m`;
} else if (css.color == "red") {
ansi2 += `\x1B[31m`;
} else if (css.color == "green") {
ansi2 += `\x1B[32m`;
} else if (css.color == "yellow") {
ansi2 += `\x1B[33m`;
} else if (css.color == "blue") {
ansi2 += `\x1B[34m`;
} else if (css.color == "magenta") {
ansi2 += `\x1B[35m`;
} else if (css.color == "cyan") {
ansi2 += `\x1B[36m`;
} else if (css.color == "white") {
ansi2 += `\x1B[37m`;
} else {
if (ArrayIsArray(css.color)) {
const { 0: r, 1: g, 2: b } = css.color;
ansi2 += `\x1B[38;2;${r};${g};${b}m`;
} else {
const parsed = parseCssColor(css.color);
if (parsed !== null) {
const { 0: r, 1: g, 2: b } = parsed;
ansi2 += `\x1B[38;2;${r};${g};${b}m`;
} else {
ansi2 += "\x1B[39m";
}
}
}
}
if (css.fontWeight != prevCss.fontWeight) {
if (css.fontWeight == "bold") {
ansi2 += `\x1B[1m`;
} else {
ansi2 += "\x1B[22m";
}
}
if (css.fontStyle != prevCss.fontStyle) {
if (css.fontStyle == "italic") {
ansi2 += `\x1B[3m`;
} else {
ansi2 += "\x1B[23m";
}
}
if (!colorEquals(css.textDecorationColor, prevCss.textDecorationColor)) {
if (css.textDecorationColor != null) {
const { 0: r, 1: g, 2: b } = css.textDecorationColor;
ansi2 += `\x1B[58;2;${r};${g};${b}m`;
} else {
ansi2 += "\x1B[59m";
}
}
if (ArrayPrototypeIncludes(css.textDecorationLine, "line-through") != ArrayPrototypeIncludes(prevCss.textDecorationLine, "line-through")) {
if (ArrayPrototypeIncludes(css.textDecorationLine, "line-through")) {
ansi2 += "\x1B[9m";
} else {
ansi2 += "\x1B[29m";
}
}
if (ArrayPrototypeIncludes(css.textDecorationLine, "overline") != ArrayPrototypeIncludes(prevCss.textDecorationLine, "overline")) {
if (ArrayPrototypeIncludes(css.textDecorationLine, "overline")) {
ansi2 += "\x1B[53m";
} else {
ansi2 += "\x1B[55m";
}
}
if (ArrayPrototypeIncludes(css.textDecorationLine, "underline") != ArrayPrototypeIncludes(prevCss.textDecorationLine, "underline")) {
if (ArrayPrototypeIncludes(css.textDecorationLine, "underline")) {
ansi2 += "\x1B[4m";
} else {
ansi2 += "\x1B[24m";
}
}
return ansi2;
}
function inspectArgs(args, inspectOptions = { __proto__: null }) {
const ctx = {
...getDefaultInspectOptions(),
colors: inspectOptions.colors ?? !noColorStdout(),
...inspectOptions
};
if (inspectOptions.iterableLimit !== void 0) {
ctx.maxArrayLength = inspectOptions.iterableLimit;
}
if (inspectOptions.strAbbreviateSize !== void 0) {
ctx.maxStringLength = inspectOptions.strAbbreviateSize;
}
if (ctx.colors)
ctx.stylize = createStylizeWithColor(styles, colors);
if (ctx.maxArrayLength === null)
ctx.maxArrayLength = Infinity;
if (ctx.maxStringLength === null)
ctx.maxStringLength = Infinity;
const noColor = !ctx.colors;
const first = args[0];
let a = 0;
let string = "";
if (typeof first == "string" && args.length > 1) {
a++;
let appendedChars = 0;
let usedStyle = false;
let prevCss = null;
for (let i = 0; i < first.length - 1; i++) {
if (first[i] == "%") {
const char = first[++i];
if (a < args.length) {
let formattedArg = null;
if (char == "s") {
formattedArg = String2(args[a++]);
} else if (ArrayPrototypeIncludes(["d", "i"], char)) {
const value = args[a++];
if (typeof value == "bigint") {
formattedArg = `${value}n`;
} else if (typeof value == "number") {
formattedArg = `${NumberParseInt(String2(value))}`;
} else {
formattedArg = "NaN";
}
} else if (char == "f") {
const value = args[a++];
if (typeof value == "number") {
formattedArg = `${value}`;
} else {
formattedArg = "NaN";
}
} else if (ArrayPrototypeIncludes(["O", "o"], char)) {
formattedArg = formatValue(ctx, args[a++], 0);
} else if (char == "c") {
const value = args[a++];
if (!noColor) {
const css = parseCss(value);
formattedArg = cssToAnsi(css, prevCss);
if (formattedArg != "") {
usedStyle = true;
prevCss = css;
}
} else {
formattedArg = "";
}
}
if (formattedArg != null) {
string += StringPrototypeSlice(first, appendedChars, i - 1) + formattedArg;
appendedChars = i + 1;
}
}
if (char == "%") {
string += StringPrototypeSlice(first, appendedChars, i - 1) + "%";
appendedChars = i + 1;
}
}
}
string += StringPrototypeSlice(first, appendedChars);
if (usedStyle) {
string += "\x1B[0m";
}
}
for (; a < args.length; a++) {
if (a > 0) {
string += " ";
}
if (typeof args[a] == "string") {
string += args[a];
} else {
string += formatValue(ctx, args[a], 0);
}
}
if (ctx.indentLevel > 0) {
const groupIndent = StringPrototypeRepeat(DEFAULT_INDENT, ctx.indentLevel);
string = groupIndent + StringPrototypeReplaceAll(string, "\n", `
${groupIndent}`);
}
return string;
}
function createStylizeWithColor(styles2, colors2) {
return function stylizeWithColor(str, styleType) {
const style = styles2[styleType];
if (style !== void 0) {
const color = colors2[style];
if (color !== void 0) {
return `\x1B[${color[0]}m${str}\x1B[${color[1]}m`;
}
}
return str;
};
}
const countMap = new SafeMap();
const timerMap = new SafeMap();
const isConsoleInstance = Symbol2("isConsoleInstance");
function getConsoleInspectOptions(noColor) {
return {
...getDefaultInspectOptions(),
colors: !noColor,
stylize: noColor ? stylizeNoColor : createStylizeWithColor(styles, colors)
};
}
class Console2 {
#printFunc = null;
[isConsoleInstance] = false;
constructor(printFunc) {
this.#printFunc = printFunc;
this.indentLevel = 0;
this[isConsoleInstance] = true;
const console = ObjectCreate(
{},
{
[SymbolToStringTag]: {
enumerable: false,
writable: false,
configurable: true,
value: "console"
}
}
);
ObjectAssign(console, this);
return console;
}
log = (...args) => {
this.#printFunc(
inspectArgs(args, {
...getConsoleInspectOptions(noColorStdout()),
indentLevel: this.indentLevel
}) + "\n",
1
);
};
debug = (...args) => {
this.#printFunc(
inspectArgs(args, {
...getConsoleInspectOptions(noColorStdout()),
indentLevel: this.indentLevel
}) + "\n",
0
);
};
info = (...args) => {
this.#printFunc(
inspectArgs(args, {
...getConsoleInspectOptions(noColorStdout()),
indentLevel: this.indentLevel
}) + "\n",
1
);
};
dir = (obj = void 0, options = { __proto__: null }) => {
this.#printFunc(
inspectArgs([obj], {
...getConsoleInspectOptions(noColorStdout()),
...options
}) + "\n",
1
);
};
dirxml = this.dir;
warn = (...args) => {
this.#printFunc(
inspectArgs(args, {
...getConsoleInspectOptions(noColorStderr()),
indentLevel: this.indentLevel
}) + "\n",
2
);
};
error = (...args) => {
this.#printFunc(
inspectArgs(args, {
...getConsoleInspectOptions(noColorStderr()),
indentLevel: this.indentLevel
}) + "\n",
3
);
};
assert = (condition = false, ...args) => {
if (condition) {
return;
}
if (args.length === 0) {
this.error("Assertion failed");
return;
}
const [first, ...rest] = new SafeArrayIterator(args);
if (typeof first === "string") {
this.error(`Assertion failed: ${first}`, ...new SafeArrayIterator(rest));
return;
}
this.error(`Assertion failed:`, ...new SafeArrayIterator(args));
};
count = (label = "default") => {
label = String2(label);
if (MapPrototypeHas(countMap, label)) {
const current = MapPrototypeGet(countMap, label) || 0;
MapPrototypeSet(countMap, label, current + 1);
} else {
MapPrototypeSet(countMap, label, 1);
}
this.info(`${label}: ${MapPrototypeGet(countMap, label)}`);
};
countReset = (label = "default") => {
label = String2(label);
if (MapPrototypeHas(countMap, label)) {
MapPrototypeSet(countMap, label, 0);
} else {
this.warn(`Count for '${label}' does not exist`);
}
};
table = (data = void 0, properties = void 0) => {
if (properties !== void 0 && !ArrayIsArray(properties)) {
throw new Error2(
"The 'properties' argument must be of type Array. Received type " + typeof properties
);
}
if (data === null || typeof data !== "object") {
return this.log(data);
}
const stringifyValue = (value) => inspectValueWithQuotes(value, {
...getDefaultInspectOptions(),
depth: 1,
compact: true
});
const toTable = (header2, body2) => this.log(cliTable(header2, body2));
let resultData;
const isSetObject = isSet2(data);
const isMapObject = isMap2(data);
const valuesKey = "Values";
const indexKey = isSetObject || isMapObject ? "(iter idx)" : "(idx)";
if (isSetObject) {
resultData = [...new SafeSetIterator(data)];
} else if (isMapObject) {
let idx = 0;
resultData = { __proto__: null };
MapPrototypeForEach(data, (v, k) => {
resultData[idx] = { Key: k, Values: v };
idx++;
});
} else {
resultData = data;
}
const keys = ObjectKeys(resultData);
const numRows = keys.length;
const objectValues = properties ? ObjectFromEntries(
ArrayPrototypeMap(properties, (name) => [
name,
ArrayPrototypeFill(new Array2(numRows), "")
])
) : {};
const indexKeys = [];
const values = [];
let hasPrimitives = false;
ArrayPrototypeForEach(keys, (k, idx) => {
const value = resultData[k];
const primitive = value === null || typeof value !== "function" && typeof value !== "object";
if (properties === void 0 && primitive) {
hasPrimitives = true;
ArrayPrototypePush(values, stringifyValue(value));
} else {
const valueObj = value || {};
const keys2 = properties || ObjectKeys(valueObj);
for (let i = 0; i < keys2.length; ++i) {
const k2 = keys2[i];
if (!primitive && ReflectHas(valueObj, k2)) {
if (!ReflectHas(objectValues, k2)) {
objectValues[k2] = ArrayPrototypeFill(new Array2(numRows), "");
}
objectValues[k2][idx] = stringifyValue(valueObj[k2]);
}
}
ArrayPrototypePush(values, "");
}
ArrayPrototypePush(indexKeys, k);
});
const headerKeys = ObjectKeys(objectValues);
const bodyValues = ObjectValues(objectValues);
const headerProps = properties || [
...new SafeArrayIterator(headerKeys),
!isMapObject && hasPrimitives && valuesKey
];
const header = ArrayPrototypeFilter(
[indexKey, ...new SafeArrayIterator(headerProps)],
Boolean2
);
const body = [indexKeys, ...new SafeArrayIterator(bodyValues), values];
toTable(header, body);
};
time = (label = "default") => {
label = String2(label);
if (MapPrototypeHas(timerMap, label)) {
this.warn(`Timer '${label}' already exists`);
return;
}
MapPrototypeSet(timerMap, label, DateNow());
};
timeLog = (label = "default", ...args) => {
label = String2(label);
if (!MapPrototypeHas(timerMap, label)) {
this.warn(`Timer '${label}' does not exist`);
return;
}
const startTime = MapPrototypeGet(timerMap, label);
const duration = DateNow() - startTime;
this.info(`${label}: ${duration}ms`, ...new SafeArrayIterator(args));
};
timeEnd = (label = "default") => {
label = String2(label);
if (!MapPrototypeHas(timerMap, label)) {
this.warn(`Timer '${label}' does not exist`);
return;
}
const startTime = MapPrototypeGet(timerMap, label);
MapPrototypeDelete(timerMap, label);
const duration = DateNow() - startTime;
this.info(`${label}: ${duration}ms`);
};
group = (...label) => {
if (label.length > 0) {
this.log(...new SafeArrayIterator(label));
}
this.indentLevel += 2;
};
groupCollapsed = this.group;
groupEnd = () => {
if (this.indentLevel > 0) {
this.indentLevel -= 2;
}
};
clear = () => {
this.indentLevel = 0;
this.#printFunc(CSI.kClear, 1);
this.#printFunc(CSI.kClearScreenDown, 1);
};
trace = (...args) => {
const message = inspectArgs(args, {
...getConsoleInspectOptions(noColorStderr()),
indentLevel: 0
});
const err = {
name: "Trace",
message
};
ErrorCaptureStackTrace(err, this.trace);
this.error(err.stack);
};
profile = (_label) => {
};
profileEnd = (_label) => {
};
timeStamp = (_label) => {
};
static [SymbolHasInstance](instance) {
return instance[isConsoleInstance];
}
}
const customInspect = SymbolFor("Deno.customInspect");
function inspect(value, inspectOptions = { __proto__: null }) {
const ctx = {
...getDefaultInspectOptions(),
...inspectOptions
};
if (inspectOptions.iterableLimit !== void 0) {
ctx.maxArrayLength = inspectOptions.iterableLimit;
}
if (inspectOptions.strAbbreviateSize !== void 0) {
ctx.maxStringLength = inspectOptions.strAbbreviateSize;
}
if (ctx.colors)
ctx.stylize = createStylizeWithColor(styles, colors);
if (ctx.maxArrayLength === null)
ctx.maxArrayLength = Infinity;
if (ctx.maxStringLength === null)
ctx.maxStringLength = Infinity;
return formatValue(ctx, value, 0);
}
function createFilteredInspectProxy({ object, keys, evaluate }) {
const obj = class {
};
if (object.constructor?.name) {
ObjectDefineProperty(obj, "name", { value: object.constructor.name });
}
return new Proxy2(new obj(), {
get(_target, key) {
if (key === SymbolToStringTag) {
return object.constructor?.name;
} else if (ArrayPrototypeIncludes(keys, key)) {
return ReflectGet(object, key);
} else {
return void 0;
}
},
getOwnPropertyDescriptor(_target, key) {
if (!ArrayPrototypeIncludes(keys, key)) {
return void 0;
} else if (evaluate) {
return getEvaluatedDescriptor(object, key);
} else {
return getDescendantPropertyDescriptor(object, key) ?? getEvaluatedDescriptor(object, key);
}
},
has(_target, key) {
return ArrayPrototypeIncludes(keys, key);
},
ownKeys() {
return keys;
}
});
function getDescendantPropertyDescriptor(object2, key) {
let propertyDescriptor = ReflectGetOwnPropertyDescriptor(object2, key);
if (!propertyDescriptor) {
const prototype = ReflectGetPrototypeOf(object2);
if (prototype) {
propertyDescriptor = getDescendantPropertyDescriptor(prototype, key);
}
}
return propertyDescriptor;
}
function getEvaluatedDescriptor(object2, key) {
return {
configurable: true,
enumerable: true,
value: object2[key]
};
}
}
return Console2;
};
function createConsole(noColorStdout = () => false, noColorStderr = () => false) {
core_default();
return console_default(noColorStdout, noColorStderr);
}
var Console = createConsole(() => false, () => false);
globalThis.console = new Console(globalThis.__print);
globalThis.Console = Console;
})();