@netlify/plugin-nextjs
Version:
Run Next.js seamlessly on Netlify
1,580 lines (1,487 loc) • 71.5 kB
JavaScript
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
import * as types from "./types.ts";
import { validateObject, validateString } from "../validators.mjs";
import { codes } from "../error_codes.ts";
import {
ALL_PROPERTIES,
getOwnNonIndexProperties,
ONLY_ENUMERABLE,
} from "../../internal_binding/util.ts";
const kObjectType = 0;
const kArrayType = 1;
const kArrayExtrasType = 2;
const kMinLineLength = 16;
// Constants to map the iterator state.
const kWeak = 0;
const kIterator = 1;
const kMapEntries = 2;
const kPending = 0;
const kRejected = 2;
// Escaped control characters (plus the single quote and the backslash). Use
// empty strings to fill up unused entries.
// deno-fmt-ignore
const meta = [
'\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
'\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F', // x0F
'\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
'\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
'', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '', // x2F
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x3F
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x4F
'', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '', // x5F
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', // x6F
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F', // x7F
'\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
'\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
'\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
'\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
];
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
const isUndetectableObject = (v) => typeof v === "undefined" && v !== undefined;
// deno-lint-ignore no-control-regex
const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c\x7f-\x9f]/;
// deno-lint-ignore no-control-regex
const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c\x7f-\x9f]/g;
// deno-lint-ignore no-control-regex
const strEscapeSequencesRegExpSingle = /[\x00-\x1f\x5c\x7f-\x9f]/;
// deno-lint-ignore no-control-regex
const strEscapeSequencesReplacerSingle = /[\x00-\x1f\x5c\x7f-\x9f]/g;
const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
const numberRegExp = /^(0|[1-9][0-9]*)$/;
const nodeModulesRegExp = /[/\\]node_modules[/\\](.+?)(?=[/\\])/g;
const classRegExp = /^(\s+[^(]*?)\s*{/;
// eslint-disable-next-line node-core/no-unescaped-regexp-dot
const stripCommentsRegExp = /(\/\/.*?\n)|(\/\*(.|\n)*?\*\/)/g;
const inspectDefaultOptions = {
showHidden: false,
depth: 2,
colors: false,
customInspect: true,
showProxy: false,
maxArrayLength: 100,
maxStringLength: 10000,
breakLength: 80,
compact: 3,
sorted: false,
getters: false,
};
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,
...ctx.userOptions,
};
// Typically, the target value will be an instance of `Object`. If that is
// *not* the case, the object may come from another vm.Context, and we want
// to avoid passing it objects from this Context in that case, so we remove
// the prototype from the returned object itself + the `stylize()` function,
// and remove all other non-primitives, including non-primitive user options.
if (isCrossContext) {
Object.setPrototypeOf(ret, null);
for (const key of Object.keys(ret)) {
if (
(typeof ret[key] === "object" || typeof ret[key] === "function") &&
ret[key] !== null
) {
delete ret[key];
}
}
ret.stylize = Object.setPrototypeOf((value, flavour) => {
let stylized;
try {
stylized = `${ctx.stylize(value, flavour)}`;
} catch {
// noop
}
if (typeof stylized !== "string") return value;
// `stylized` is a string as it should be, which is safe to pass along.
return stylized;
}, null);
}
return ret;
}
/**
* Echos the value of any input. Tries to print the value out
* in the best way possible given the different types.
*/
/* Legacy: value, showHidden, depth, colors */
export function inspect(value, opts) {
// Default options
const ctx = {
budget: {},
indentationLvl: 0,
seen: [],
currentDepth: 0,
stylize: stylizeNoColor,
showHidden: inspectDefaultOptions.showHidden,
depth: inspectDefaultOptions.depth,
colors: inspectDefaultOptions.colors,
customInspect: inspectDefaultOptions.customInspect,
showProxy: inspectDefaultOptions.showProxy,
maxArrayLength: inspectDefaultOptions.maxArrayLength,
maxStringLength: inspectDefaultOptions.maxStringLength,
breakLength: inspectDefaultOptions.breakLength,
compact: inspectDefaultOptions.compact,
sorted: inspectDefaultOptions.sorted,
getters: inspectDefaultOptions.getters,
};
if (arguments.length > 1) {
// Legacy...
if (arguments.length > 2) {
if (arguments[2] !== undefined) {
ctx.depth = arguments[2];
}
if (arguments.length > 3 && arguments[3] !== undefined) {
ctx.colors = arguments[3];
}
}
// Set user-specified options
if (typeof opts === "boolean") {
ctx.showHidden = opts;
} else if (opts) {
const optKeys = Object.keys(opts);
for (let i = 0; i < optKeys.length; ++i) {
const key = optKeys[i];
// TODO(BridgeAR): Find a solution what to do about stylize. Either make
// this function public or add a new API with a similar or better
// functionality.
if (
// deno-lint-ignore no-prototype-builtins
inspectDefaultOptions.hasOwnProperty(key) ||
key === "stylize"
) {
ctx[key] = opts[key];
} else if (ctx.userOptions === undefined) {
// This is required to pass through the actual user input.
ctx.userOptions = opts;
}
}
}
}
if (ctx.colors) ctx.stylize = stylizeWithColor;
if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;
if (ctx.maxStringLength === null) ctx.maxStringLength = Infinity;
return formatValue(ctx, value, 0);
}
const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
inspect.custom = customInspectSymbol;
Object.defineProperty(inspect, "defaultOptions", {
get() {
return inspectDefaultOptions;
},
set(options) {
validateObject(options, "options");
return Object.assign(inspectDefaultOptions, options);
},
});
// Set Graphics Rendition https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
// Each color consists of an array with the color code as first entry and the
// reset code as second entry.
const defaultFG = 39;
const defaultBG = 49;
inspect.colors = Object.assign(Object.create(null), {
reset: [0, 0],
bold: [1, 22],
dim: [2, 22], // Alias: faint
italic: [3, 23],
underline: [4, 24],
blink: [5, 25],
// Swap foreground and background colors
inverse: [7, 27], // Alias: swapcolors, swapColors
hidden: [8, 28], // Alias: conceal
strikethrough: [9, 29], // Alias: strikeThrough, crossedout, crossedOut
doubleunderline: [21, 24], // Alias: doubleUnderline
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], // Alias: grey, blackBright
redBright: [91, defaultFG],
greenBright: [92, defaultFG],
yellowBright: [93, defaultFG],
blueBright: [94, defaultFG],
magentaBright: [95, defaultFG],
cyanBright: [96, defaultFG],
whiteBright: [97, defaultFG],
bgGray: [100, defaultBG], // Alias: bgGrey, bgBlackBright
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) {
Object.defineProperty(inspect.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");
// TODO(BridgeAR): Add function style support for more complex styles.
// Don't use 'blue' not visible on cmd.exe
inspect.styles = Object.assign(Object.create(null), {
special: "cyan",
number: "yellow",
bigint: "yellow",
boolean: "yellow",
undefined: "grey",
null: "bold",
string: "green",
symbol: "green",
date: "magenta",
// "name": intentionally not styling
// TODO(BridgeAR): Highlight regular expressions properly.
regexp: "red",
module: "underline",
});
function addQuotes(str, quotes) {
if (quotes === -1) {
return `"${str}"`;
}
if (quotes === -2) {
return `\`${str}\``;
}
return `'${str}'`;
}
// TODO(wafuwafu13): Figure out
const escapeFn = (str) => meta[str.charCodeAt(0)];
// Escape control characters, single quotes and the backslash.
// This is similar to JSON stringify escaping.
function strEscape(str) {
let escapeTest = strEscapeSequencesRegExp;
let escapeReplace = strEscapeSequencesReplacer;
let singleQuote = 39;
// Check for double quotes. If not present, do not escape single quotes and
// instead wrap the text in double quotes. If double quotes exist, check for
// backticks. If they do not exist, use those as fallback instead of the
// double quotes.
if (str.includes("'")) {
// This invalidates the charCode and therefore can not be matched for
// anymore.
if (!str.includes('"')) {
singleQuote = -1;
} else if (
!str.includes("`") &&
!str.includes("${")
) {
singleQuote = -2;
}
if (singleQuote !== 39) {
escapeTest = strEscapeSequencesRegExpSingle;
escapeReplace = strEscapeSequencesReplacerSingle;
}
}
// Some magic numbers that worked out fine while benchmarking with v8 6.0
if (str.length < 5000 && !escapeTest.test(str)) {
return addQuotes(str, singleQuote);
}
if (str.length > 100) {
str = str.replace(escapeReplace, escapeFn);
return addQuotes(str, singleQuote);
}
let result = "";
let last = 0;
const lastIndex = str.length;
for (let i = 0; i < lastIndex; i++) {
const point = str.charCodeAt(i);
if (
point === singleQuote ||
point === 92 ||
point < 32 ||
(point > 126 && point < 160)
) {
if (last === i) {
result += meta[point];
} else {
result += `${str.slice(last, i)}${meta[point]}`;
}
last = i + 1;
}
}
if (last !== lastIndex) {
result += str.slice(last);
}
return addQuotes(result, singleQuote);
}
function stylizeWithColor(str, styleType) {
const style = inspect.styles[styleType];
if (style !== undefined) {
const color = inspect.colors[style];
if (color !== undefined) {
return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`;
}
}
return str;
}
function stylizeNoColor(str) {
return str;
}
// Note: using `formatValue` directly requires the indentation level to be
// corrected by setting `ctx.indentationLvL += diff` and then to decrease the
// value afterwards again.
function formatValue(
ctx,
value,
recurseTimes,
typedArray,
) {
// Primitive types cannot have properties.
if (
typeof value !== "object" &&
typeof value !== "function" &&
!isUndetectableObject(value)
) {
return formatPrimitive(ctx.stylize, value, ctx);
}
if (value === null) {
return ctx.stylize("null", "null");
}
// Memorize the context for custom inspection on proxies.
const context = value;
// Always check for proxies to prevent side effects and to prevent triggering
// any proxy handlers.
// TODO(wafuwafu13): Set Proxy
const proxy = undefined;
// const proxy = getProxyDetails(value, !!ctx.showProxy);
// if (proxy !== undefined) {
// if (ctx.showProxy) {
// return formatProxy(ctx, proxy, recurseTimes);
// }
// value = proxy;
// }
// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it.
if (ctx.customInspect) {
const maybeCustom = value[customInspectSymbol];
if (
typeof maybeCustom === "function" &&
// Filter out the util module, its inspect function is special.
maybeCustom !== inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)
) {
// This makes sure the recurseTimes are reported as before while using
// a counter internally.
const depth = ctx.depth === null ? null : ctx.depth - recurseTimes;
const isCrossContext = proxy !== undefined ||
!(context instanceof Object);
const ret = maybeCustom.call(
context,
depth,
getUserOptions(ctx, isCrossContext),
);
// If the custom inspection method returned `this`, don't go into
// infinite recursion.
if (ret !== context) {
if (typeof ret !== "string") {
return formatValue(ctx, ret, recurseTimes);
}
return ret.replace(/\n/g, `\n${" ".repeat(ctx.indentationLvl)}`);
}
}
}
// Using an array here is actually better for the average case than using
// a Set. `seen` will only check for the depth and will never grow too large.
if (ctx.seen.includes(value)) {
let index = 1;
if (ctx.circular === undefined) {
ctx.circular = new Map();
ctx.circular.set(value, index);
} else {
index = ctx.circular.get(value);
if (index === undefined) {
index = ctx.circular.size + 1;
ctx.circular.set(value, index);
}
}
return ctx.stylize(`[Circular *${index}]`, "special");
}
return formatRaw(ctx, value, recurseTimes, typedArray);
}
function formatRaw(ctx, value, recurseTimes, typedArray) {
let keys;
let protoProps;
if (ctx.showHidden && (recurseTimes <= ctx.depth || ctx.depth === null)) {
protoProps = [];
}
const constructor = getConstructorName(value, ctx, recurseTimes, protoProps);
// Reset the variable to check for this later on.
if (protoProps !== undefined && protoProps.length === 0) {
protoProps = undefined;
}
let tag = value[Symbol.toStringTag];
// Only list the tag in case it's non-enumerable / not an own property.
// Otherwise we'd print this twice.
if (
typeof tag !== "string"
// TODO(wafuwafu13): Implement
// (tag !== "" &&
// (ctx.showHidden
// ? Object.prototype.hasOwnProperty
// : Object.prototype.propertyIsEnumerable)(
// value,
// Symbol.toStringTag,
// ))
) {
tag = "";
}
let base = "";
let formatter = getEmptyFormatArray;
let braces;
let noIterator = true;
let i = 0;
const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
let extrasType = kObjectType;
// Iterators and the rest are split to reduce checks.
// We have to check all values in case the constructor is set to null.
// Otherwise it would not possible to identify all types properly.
if (value[Symbol.iterator] || constructor === null) {
noIterator = false;
if (Array.isArray(value)) {
// Only set the constructor for non ordinary ("Array [...]") arrays.
const prefix = (constructor !== "Array" || tag !== "")
? getPrefix(constructor, tag, "Array", `(${value.length})`)
: "";
keys = getOwnNonIndexProperties(value, filter);
braces = [`${prefix}[`, "]"];
if (value.length === 0 && keys.length === 0 && protoProps === undefined) {
return `${braces[0]}]`;
}
extrasType = kArrayExtrasType;
formatter = formatArray;
} else if (types.isSet(value)) {
const size = value.size;
const prefix = getPrefix(constructor, tag, "Set", `(${size})`);
keys = getKeys(value, ctx.showHidden);
formatter = constructor !== null
? formatSet.bind(null, value)
: formatSet.bind(null, value.values());
if (size === 0 && keys.length === 0 && protoProps === undefined) {
return `${prefix}{}`;
}
braces = [`${prefix}{`, "}"];
} else if (types.isMap(value)) {
const size = value.size;
const prefix = getPrefix(constructor, tag, "Map", `(${size})`);
keys = getKeys(value, ctx.showHidden);
formatter = constructor !== null
? formatMap.bind(null, value)
: formatMap.bind(null, value.entries());
if (size === 0 && keys.length === 0 && protoProps === undefined) {
return `${prefix}{}`;
}
braces = [`${prefix}{`, "}"];
} else if (types.isTypedArray(value)) {
keys = getOwnNonIndexProperties(value, filter);
const bound = value;
const fallback = "";
if (constructor === null) {
// TODO(wafuwafu13): Implement
// fallback = TypedArrayPrototypeGetSymbolToStringTag(value);
// // Reconstruct the array information.
// bound = new primordials[fallback](value);
}
const size = value.length;
const prefix = getPrefix(constructor, tag, fallback, `(${size})`);
braces = [`${prefix}[`, "]"];
if (value.length === 0 && keys.length === 0 && !ctx.showHidden) {
return `${braces[0]}]`;
}
// Special handle the value. The original value is required below. The
// bound function is required to reconstruct missing information.
(formatter) = formatTypedArray.bind(null, bound, size);
extrasType = kArrayExtrasType;
} else if (types.isMapIterator(value)) {
keys = getKeys(value, ctx.showHidden);
braces = getIteratorBraces("Map", tag);
// Add braces to the formatter parameters.
(formatter) = formatIterator.bind(null, braces);
} else if (types.isSetIterator(value)) {
keys = getKeys(value, ctx.showHidden);
braces = getIteratorBraces("Set", tag);
// Add braces to the formatter parameters.
(formatter) = formatIterator.bind(null, braces);
} else {
noIterator = true;
}
}
if (noIterator) {
keys = getKeys(value, ctx.showHidden);
braces = ["{", "}"];
if (constructor === "Object") {
if (types.isArgumentsObject(value)) {
braces[0] = "[Arguments] {";
} else if (tag !== "") {
braces[0] = `${getPrefix(constructor, tag, "Object")}{`;
}
if (keys.length === 0 && protoProps === undefined) {
return `${braces[0]}}`;
}
} else if (typeof value === "function") {
base = getFunctionBase(value, constructor, tag);
if (keys.length === 0 && protoProps === undefined) {
return ctx.stylize(base, "special");
}
} else if (types.isRegExp(value)) {
// Make RegExps say that they are RegExps
base = RegExp(constructor !== null ? value : new RegExp(value))
.toString();
const prefix = getPrefix(constructor, tag, "RegExp");
if (prefix !== "RegExp ") {
base = `${prefix}${base}`;
}
if (
(keys.length === 0 && protoProps === undefined) ||
(recurseTimes > ctx.depth && ctx.depth !== null)
) {
return ctx.stylize(base, "regexp");
}
} else if (types.isDate(value)) {
// Make dates with properties first say the date
base = Number.isNaN(value.getTime())
? value.toString()
: value.toISOString();
const prefix = getPrefix(constructor, tag, "Date");
if (prefix !== "Date ") {
base = `${prefix}${base}`;
}
if (keys.length === 0 && protoProps === undefined) {
return ctx.stylize(base, "date");
}
} else if (value instanceof Error) {
base = formatError(value, constructor, tag, ctx, keys);
if (keys.length === 0 && protoProps === undefined) {
return base;
}
} else if (types.isAnyArrayBuffer(value)) {
// Fast path for ArrayBuffer and SharedArrayBuffer.
// Can't do the same for DataView because it has a non-primitive
// .buffer property that we need to recurse for.
const arrayType = types.isArrayBuffer(value)
? "ArrayBuffer"
: "SharedArrayBuffer";
const prefix = getPrefix(constructor, tag, arrayType);
if (typedArray === undefined) {
(formatter) = formatArrayBuffer;
} else if (keys.length === 0 && protoProps === undefined) {
return prefix +
`{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`;
}
braces[0] = `${prefix}{`;
Array.prototype.unshift.call(keys, "byteLength");
} else if (types.isDataView(value)) {
braces[0] = `${getPrefix(constructor, tag, "DataView")}{`;
// .buffer goes last, it's not a primitive like the others.
Array.prototype.unshift.call(keys, "byteLength", "byteOffset", "buffer");
} else if (types.isPromise(value)) {
braces[0] = `${getPrefix(constructor, tag, "Promise")}{`;
(formatter) = formatPromise;
} else if (types.isWeakSet(value)) {
braces[0] = `${getPrefix(constructor, tag, "WeakSet")}{`;
(formatter) = ctx.showHidden ? formatWeakSet : formatWeakCollection;
} else if (types.isWeakMap(value)) {
braces[0] = `${getPrefix(constructor, tag, "WeakMap")}{`;
(formatter) = ctx.showHidden ? formatWeakMap : formatWeakCollection;
} else if (types.isModuleNamespaceObject(value)) {
braces[0] = `${getPrefix(constructor, tag, "Module")}{`;
// Special handle keys for namespace objects.
(formatter) = formatNamespaceObject.bind(null, keys);
} else if (types.isBoxedPrimitive(value)) {
base = getBoxedBase(value, ctx, keys, constructor, tag);
if (keys.length === 0 && protoProps === undefined) {
return base;
}
} else {
if (keys.length === 0 && protoProps === undefined) {
// TODO(wafuwafu13): Implement
// if (types.isExternal(value)) {
// const address = getExternalValue(value).toString(16);
// return ctx.stylize(`[External: ${address}]`, 'special');
// }
return `${getCtxStyle(value, constructor, tag)}{}`;
}
braces[0] = `${getCtxStyle(value, constructor, tag)}{`;
}
}
if (recurseTimes > ctx.depth && ctx.depth !== null) {
let constructorName = getCtxStyle(value, constructor, tag).slice(0, -1);
if (constructor !== null) {
constructorName = `[${constructorName}]`;
}
return ctx.stylize(constructorName, "special");
}
recurseTimes += 1;
ctx.seen.push(value);
ctx.currentDepth = recurseTimes;
let output;
const indentationLvl = ctx.indentationLvl;
try {
output = formatter(ctx, value, recurseTimes);
for (i = 0; i < keys.length; i++) {
output.push(
formatProperty(ctx, value, recurseTimes, keys[i], extrasType),
);
}
if (protoProps !== undefined) {
output.push(...protoProps);
}
} catch (err) {
const constructorName = getCtxStyle(value, constructor, tag).slice(0, -1);
return handleMaxCallStackSize(ctx, err, constructorName, indentationLvl);
}
if (ctx.circular !== undefined) {
const index = ctx.circular.get(value);
if (index !== undefined) {
const reference = ctx.stylize(`<ref *${index}>`, "special");
// Add reference always to the very beginning of the output.
if (ctx.compact !== true) {
base = base === "" ? reference : `${reference} ${base}`;
} else {
braces[0] = `${reference} ${braces[0]}`;
}
}
}
ctx.seen.pop();
if (ctx.sorted) {
const comparator = ctx.sorted === true ? undefined : ctx.sorted;
if (extrasType === kObjectType) {
output = output.sort(comparator);
} else if (keys.length > 1) {
const sorted = output.slice(output.length - keys.length).sort(comparator);
output.splice(output.length - keys.length, keys.length, ...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 any indentationLvl exceeds this limit, limit further inspecting to the
// minimum. Otherwise the recursive algorithm might continue inspecting the
// object even though the maximum string size (~2 ** 28 on 32 bit systems and
// ~2 ** 30 on 64 bit systems) exceeded. The actual output is not limited at
// exactly 2 ** 27 but a bit higher. This depends on the object shape.
// This limit also makes sure that huge objects don't block the event loop
// significantly.
if (newLength > 2 ** 27) {
ctx.depth = -1;
}
return res;
}
const builtInObjects = new Set(
Object.getOwnPropertyNames(globalThis).filter((e) =>
/^[A-Z][a-zA-Z0-9]+$/.test(e)
),
);
function addPrototypeProperties(
ctx,
main,
obj,
recurseTimes,
output,
) {
let depth = 0;
let keys;
let keySet;
do {
if (depth !== 0 || main === obj) {
obj = Object.getPrototypeOf(obj);
// Stop as soon as a null prototype is encountered.
if (obj === null) {
return;
}
// Stop as soon as a built-in object type is detected.
const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor");
if (
descriptor !== undefined &&
typeof descriptor.value === "function" &&
builtInObjects.has(descriptor.value.name)
) {
return;
}
}
if (depth === 0) {
keySet = new Set();
} else {
Array.prototype.forEach.call(keys, (key) => keySet.add(key));
}
// Get all own property names and symbols.
keys = Reflect.ownKeys(obj);
Array.prototype.push.call(ctx.seen, main);
for (const key of keys) {
// Ignore the `constructor` property and keys that exist on layers above.
if (
key === "constructor" ||
// deno-lint-ignore no-prototype-builtins
main.hasOwnProperty(key) ||
(depth !== 0 && keySet.has(key))
) {
continue;
}
const desc = Object.getOwnPropertyDescriptor(obj, key);
if (typeof desc.value === "function") {
continue;
}
const value = formatProperty(
ctx,
obj,
recurseTimes,
key,
kObjectType,
desc,
main,
);
if (ctx.colors) {
// Faint!
Array.prototype.push.call(output, `\u001b[2m${value}\u001b[22m`);
} else {
Array.prototype.push.call(output, value);
}
}
Array.prototype.pop.call(ctx.seen);
// Limit the inspection to up to three prototype layers. Using `recurseTimes`
// is not a good choice here, because it's as if the properties are declared
// on the current object from the users perspective.
} while (++depth !== 3);
}
function getConstructorName(
obj,
ctx,
recurseTimes,
protoProps,
) {
let firstProto;
const tmp = obj;
while (obj || isUndetectableObject(obj)) {
const descriptor = Object.getOwnPropertyDescriptor(obj, "constructor");
if (
descriptor !== undefined &&
typeof descriptor.value === "function" &&
descriptor.value.name !== "" &&
isInstanceof(tmp, descriptor.value)
) {
if (
protoProps !== undefined &&
(firstProto !== obj ||
!builtInObjects.has(descriptor.value.name))
) {
addPrototypeProperties(
ctx,
tmp,
firstProto || tmp,
recurseTimes,
protoProps,
);
}
return descriptor.value.name;
}
obj = Object.getPrototypeOf(obj);
if (firstProto === undefined) {
firstProto = obj;
}
}
if (firstProto === null) {
return null;
}
// TODO(wafuwafu13): Implement
// const res = internalGetConstructorName(tmp);
const res = undefined;
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}>`;
}
function formatPrimitive(fn, value, ctx) {
if (typeof value === "string") {
let trailer = "";
if (value.length > ctx.maxStringLength) {
const remaining = value.length - ctx.maxStringLength;
value = value.slice(0, ctx.maxStringLength);
trailer = `... ${remaining} more character${remaining > 1 ? "s" : ""}`;
}
if (
ctx.compact !== true &&
// TODO(BridgeAR): Add unicode support. Use the readline getStringWidth
// function.
value.length > kMinLineLength &&
value.length > ctx.breakLength - ctx.indentationLvl - 4
) {
return value
.split(/(?<=\n)/)
.map((line) => fn(strEscape(line), "string"))
.join(` +\n${" ".repeat(ctx.indentationLvl + 2)}`) + trailer;
}
return fn(strEscape(value), "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");
}
// es6 symbol primitive
return fn(value.toString(), "symbol");
}
// Return a new empty array to push in the results of the default formatter.
function getEmptyFormatArray() {
return [];
}
function isInstanceof(object, proto) {
try {
return object instanceof proto;
} catch {
return false;
}
}
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 = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
const remaining = valLen - len;
const output = [];
for (let i = 0; i < len; i++) {
// Special handle sparse arrays.
// deno-lint-ignore no-prototype-builtins
if (!value.hasOwnProperty(i)) {
return formatSpecialArray(ctx, value, recurseTimes, len, output, i);
}
output.push(formatProperty(ctx, value, recurseTimes, i, kArrayType));
}
if (remaining > 0) {
output.push(`... ${remaining} more item${remaining > 1 ? "s" : ""}`);
}
return output;
}
function getCtxStyle(_value, constructor, tag) {
let fallback = "";
if (constructor === null) {
// TODO(wafuwafu13): Implement
// fallback = internalGetConstructorName(value);
if (fallback === tag) {
fallback = "Object";
}
}
return getPrefix(constructor, tag, fallback);
}
// Look up the keys of the object.
function getKeys(value, showHidden) {
let keys;
const symbols = Object.getOwnPropertySymbols(value);
if (showHidden) {
keys = Object.getOwnPropertyNames(value);
if (symbols.length !== 0) {
Array.prototype.push.apply(keys, symbols);
}
} else {
// This might throw if `value` is a Module Namespace Object from an
// unevaluated module, but we don't want to perform the actual type
// check because it's expensive.
// TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209
// and modify this logic as needed.
try {
keys = Object.keys(value);
} catch (_err) {
// TODO(wafuwafu13): Implement
// assert(isNativeError(err) && err.name === 'ReferenceError' &&
// isModuleNamespaceObject(value));
keys = Object.getOwnPropertyNames(value);
}
if (symbols.length !== 0) {
// TODO(wafuwafu13): Implement
// const filter = (key: any) =>
//
// Object.prototype.propertyIsEnumerable(value, key);
// Array.prototype.push.apply(
// keys,
// symbols.filter(filter),
// );
}
}
return keys;
}
function formatSet(value, ctx, _ignored, recurseTimes) {
const output = [];
ctx.indentationLvl += 2;
for (const v of value) {
Array.prototype.push.call(output, formatValue(ctx, v, recurseTimes));
}
ctx.indentationLvl -= 2;
return output;
}
function formatMap(value, ctx, _gnored, recurseTimes) {
const output = [];
ctx.indentationLvl += 2;
for (const { 0: k, 1: v } of value) {
output.push(
`${formatValue(ctx, k, recurseTimes)} => ${
formatValue(ctx, v, recurseTimes)
}`,
);
}
ctx.indentationLvl -= 2;
return output;
}
function formatTypedArray(
value,
length,
ctx,
_ignored,
recurseTimes,
) {
const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), length);
const remaining = value.length - maxLength;
const output = new Array(maxLength);
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) {
// .buffer goes last, it's not a primitive like the others.
// All besides `BYTES_PER_ELEMENT` are actually getters.
ctx.indentationLvl += 2;
for (
const key of [
"BYTES_PER_ELEMENT",
"length",
"byteLength",
"byteOffset",
"buffer",
]
) {
const str = formatValue(ctx, value[key], recurseTimes, true);
Array.prototype.push.call(output, `[${key}]: ${str}`);
}
ctx.indentationLvl -= 2;
}
return output;
}
function getIteratorBraces(type, tag) {
if (tag !== `${type} Iterator`) {
if (tag !== "") {
tag += "] [";
}
tag += `${type} Iterator`;
}
return [`[${tag}] {`, "}"];
}
function formatIterator(braces, ctx, value, recurseTimes) {
// TODO(wafuwafu13): Implement
// const { 0: entries, 1: isKeyValue } = previewEntries(value, true);
const { 0: entries, 1: isKeyValue } = value;
if (isKeyValue) {
// Mark entry iterators as such.
braces[0] = braces[0].replace(/ Iterator] {$/, " Entries] {");
return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);
}
return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
}
function getFunctionBase(value, constructor, tag) {
const stringified = Function.prototype.toString.call(value);
if (stringified.slice(0, 5) === "class" && stringified.endsWith("}")) {
const slice = stringified.slice(5, -1);
const bracketIndex = slice.indexOf("{");
if (
bracketIndex !== -1 &&
(!slice.slice(0, bracketIndex).includes("(") ||
// Slow path to guarantee that it's indeed a class.
classRegExp.test(slice.replace(stripCommentsRegExp)))
) {
return getClassBase(value, constructor, tag);
}
}
let type = "Function";
if (types.isGeneratorFunction(value)) {
type = `Generator${type}`;
}
if (types.isAsyncFunction(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 formatError(
err,
constructor,
tag,
ctx,
keys,
) {
const name = err.name != null ? String(err.name) : "Error";
let len = name.length;
let stack = err.stack ? String(err.stack) : err.toString();
// Do not "duplicate" error properties that are already included in the output
// otherwise.
if (!ctx.showHidden && keys.length !== 0) {
for (const name of ["name", "message", "stack"]) {
const index = keys.indexOf(name);
// Only hide the property in case it's part of the original stack
if (index !== -1 && stack.includes(err[name])) {
keys.splice(index, 1);
}
}
}
// A stack trace may contain arbitrary data. Only manipulate the output
// for "regular errors" (errors that "look normal") for now.
if (
constructor === null ||
(name.endsWith("Error") &&
stack.startsWith(name) &&
(stack.length === len || stack[len] === ":" || stack[len] === "\n"))
) {
let fallback = "Error";
if (constructor === null) {
const start = stack.match(/^([A-Z][a-z_ A-Z0-9[\]()-]+)(?::|\n {4}at)/) ||
stack.match(/^([a-z_A-Z0-9-]*Error)$/);
fallback = (start && start[1]) || "";
len = fallback.length;
fallback = fallback || "Error";
}
const prefix = getPrefix(constructor, tag, fallback).slice(0, -1);
if (name !== prefix) {
if (prefix.includes(name)) {
if (len === 0) {
stack = `${prefix}: ${stack}`;
} else {
stack = `${prefix}${stack.slice(len)}`;
}
} else {
stack = `${prefix} [${name}]${stack.slice(len)}`;
}
}
}
// Ignore the error message if it's contained in the stack.
let pos = (err.message && stack.indexOf(err.message)) || -1;
if (pos !== -1) {
pos += err.message.length;
}
// Wrap the error in brackets in case it has no stack trace.
const stackStart = stack.indexOf("\n at", pos);
if (stackStart === -1) {
stack = `[${stack}]`;
} else if (ctx.colors) {
// Highlight userland code and node modules.
let newStack = stack.slice(0, stackStart);
const lines = stack.slice(stackStart + 1).split("\n");
for (const line of lines) {
// const core = line.match(coreModuleRegExp);
// TODO(wafuwafu13): Implement
// if (core !== null && NativeModule.exists(core[1])) {
// newStack += `\n${ctx.stylize(line, 'undefined')}`;
// } else {
// This adds underscores to all node_modules to quickly identify them.
let nodeModule;
newStack += "\n";
let pos = 0;
// deno-lint-ignore no-cond-assign
while (nodeModule = nodeModulesRegExp.exec(line)) {
// '/node_modules/'.length === 14
newStack += line.slice(pos, nodeModule.index + 14);
newStack += ctx.stylize(nodeModule[1], "module");
pos = nodeModule.index + nodeModule[0].length;
}
newStack += pos === 0 ? line : line.slice(pos);
// }
}
stack = newStack;
}
// The message and the stack have to be indented as well!
if (ctx.indentationLvl !== 0) {
const indentation = " ".repeat(ctx.indentationLvl);
stack = stack.replace(/\n/g, `\n${indentation}`);
}
return stack;
}
let hexSlice;
function formatArrayBuffer(ctx, value) {
let buffer;
try {
buffer = new Uint8Array(value);
} catch {
return [ctx.stylize("(detached)", "special")];
}
// TODO(wafuwafu13): Implement
// if (hexSlice === undefined)
// hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice);
let str = hexSlice(buffer, 0, Math.min(ctx.maxArrayLength, buffer.length))
.replace(/(.{2})/g, "$1 ").trim();
const remaining = buffer.length - ctx.maxArrayLength;
if (remaining > 0) {
str += ` ... ${remaining} more byte${remaining > 1 ? "s" : ""}`;
}
return [`${ctx.stylize("[Uint8Contents]", "special")}: <${str}>`];
}
function formatNumber(fn, value) {
// Format -0 as '-0'. Checking `value === -0` won't distinguish 0 from -0.
return fn(Object.is(value, -0) ? "-0" : `${value}`, "number");
}
function formatPromise(ctx, value, recurseTimes) {
let output;
// TODO(wafuwafu13): Implement
// const { 0: state, 1: result } = getPromiseDetails(value);
const { 0: state, 1: result } = value;
if (state === kPending) {
output = [ctx.stylize("<pending>", "special")];
} else {
ctx.indentationLvl += 2;
const str = formatValue(ctx, result, recurseTimes);
ctx.indentationLvl -= 2;
output = [
state === kRejected
? `${ctx.stylize("<rejected>", "special")} ${str}`
: str,
];
}
return output;
}
function formatWeakCollection(ctx) {
return [ctx.stylize("<items unknown>", "special")];
}
function formatWeakSet(ctx, value, recurseTimes) {
// TODO(wafuwafu13): Implement
// const entries = previewEntries(value);
const entries = value;
return formatSetIterInner(ctx, recurseTimes, entries, kWeak);
}
function formatWeakMap(ctx, value, recurseTimes) {
// TODO(wafuwafu13): Implement
// const entries = previewEntries(value);
const entries = value;
return formatMapIterInner(ctx, recurseTimes, entries, kWeak);
}
function formatProperty(
ctx,
value,
recurseTimes,
key,
type,
desc,
original = value,
) {
let name, str;
let extra = " ";
desc = desc || Object.getOwnPropertyDescriptor(value, key) ||
{ value: value[key], enumerable: true };
if (desc.value !== undefined) {
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 = `\n${" ".repeat(ctx.indentationLvl)}`;
}
ctx.indentationLvl -= diff;
} else if (desc.get !== undefined) {
const label = desc.set !== undefined ? "Getter/Setter" : "Getter";
const s = ctx.stylize;
const sp = "special";
if (
ctx.getters && (ctx.getters === true ||
(ctx.getters === "get" && desc.set === undefined) ||
(ctx.getters === "set" && desc.set !== undefined))
) {
try {
const tmp = desc.get.call(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 !== undefined) {
str = ctx.stylize("[Setter]", "special");
} else {
str = ctx.stylize("undefined", "undefined");
}
if (type === kArrayType) {
return str;
}
if (typeof key === "symbol") {
const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
name = `[${ctx.stylize(tmp, "symbol")}]`;
} else if (key === "__proto__") {
name = "['__proto__']";
} else if (desc.enumerable === false) {
const tmp = key.replace(strEscapeSequencesReplacer, escapeFn);
name = `[${tmp}]`;
} else if (keyStrRegExp.test(key)) {
name = ctx.stylize(key, "name");
} else {
name = ctx.stylize(strEscape(key), "string");
}
return `${name}:${extra}${str}`;
}
function handleMaxCallStackSize(
_ctx,
_err,
_constructorName,
_indentationLvl,
) {
// TODO(wafuwafu13): Implement
// if (types.isStackOverflowError(err)) {
// ctx.seen.pop();
// ctx.indentationLvl = indentationLvl;
// return ctx.stylize(
// `[${constructorName}: Inspection interrupted ` +
// 'prematurely. Maximum call stack size exceeded.]',
// 'special'
// );
// }
// /* c8 ignore next */
// assert.fail(err.stack);
}
// deno-lint-ignore no-control-regex
const colorRegExp = /\u001b\[\d\d?m/g;
function removeColors(str) {
return str.replace(colorRegExp, "");
}
function isBelowBreakLength(ctx, output, start, base) {
// Each entry is separated by at least a comma. Thus, we start with a total
// length of at least `output.length`. In addition, some cases have a
// whitespace in-between each other that is added to the total as well.
// TODO(BridgeAR): Add unicode support. Use the readline getStringWidth
// function. Check the performance overhead and make it an opt-in in case it's
// significant.
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;
}
}
// Do not line up properties on the same line if `base` contains line breaks.
return base === "" || !base.includes("\n");
}
function formatBigInt(fn, value) {
return fn(`${value}n`, "bigint");
}
function formatNamespaceObject(
keys,
ctx,
value,
recurseTimes,
) {
const output = new Array(keys.length);
for (let i = 0; i < keys.length; i++) {
try {
output[i] = formatProperty(
ctx,
value,
recurseTimes,
keys[i],
kObjectType,
);
} catch (_err) {
// TODO(wafuwfu13): Implement
// assert(isNativeError(err) && err.name === 'ReferenceError');
// Use the existing functionality. This makes sure the indentation and
// line breaks are always correct. Otherwise it is very difficult to keep
// this aligned, even though this is a hacky way of dealing with this.
const tmp = { [keys[i]]: "" };
output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);
const pos = output[i].lastIndexOf(" ");
// We have to find the last whitespace and have to replace that value as
// it will be visualized as a regular string.
output[i] = output[i].slice(0, pos + 1) +
ctx.stylize("<uninitialized>", "special");
}
}
// Reset the keys to an empty array. This prevents duplicated inspection.
keys.length = 0;
return output;
}
// The array is sparse and/or has extra keys
function formatSpecialArray(
ctx,
value,
recurseTimes,
maxLength,
output,
i,
) {
const keys = Object.keys(value);
let index = i;
for (; i < keys.length && output.length < maxLength; i++) {
const key = keys[i];
const tmp = +key;
// Arrays can only have up to 2^32 - 1 entries
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}>`;
output.push(ctx.stylize(message, "undefined"));
index = tmp;
if (output.length === maxLength) {
break;
}
}
output.push(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}>`;
output.push(ctx.stylize(message, "undefined"));
}
} else if (remaining > 0) {
output.push(`... ${remaining} more item${remaining > 1 ? "s" : ""}`);
}
return output;
}
function getBoxedBase(
value,
ctx,
keys,
constructor,
tag,
) {
let type;
if (types.isNumberObject(value)) {
type = "Number";
} else if (types.