summaryrefslogtreecommitdiff
path: root/cli/tsc/02_console.js
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tsc/02_console.js')
-rw-r--r--cli/tsc/02_console.js1183
1 files changed, 1183 insertions, 0 deletions
diff --git a/cli/tsc/02_console.js b/cli/tsc/02_console.js
new file mode 100644
index 000000000..5a9dd4186
--- /dev/null
+++ b/cli/tsc/02_console.js
@@ -0,0 +1,1183 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+((window) => {
+ const exposeForTest = window.__bootstrap.internals.exposeForTest;
+ const {
+ stripColor,
+ yellow,
+ dim,
+ cyan,
+ red,
+ green,
+ magenta,
+ bold,
+ } = window.__bootstrap.colors;
+
+ const {
+ isTypedArray,
+ isInvalidDate,
+ hasOwnProperty,
+ } = window.__bootstrap.webUtil;
+
+ // Copyright Joyent, Inc. and other Node contributors. MIT license.
+ // Forked from Node's lib/internal/cli_table.js
+
+ const tableChars = {
+ middleMiddle: "─",
+ rowMiddle: "┼",
+ topRight: "┐",
+ topLeft: "┌",
+ leftMiddle: "├",
+ topMiddle: "┬",
+ bottomRight: "┘",
+ bottomLeft: "└",
+ bottomMiddle: "┴",
+ rightMiddle: "┤",
+ left: "│ ",
+ right: " │",
+ middle: " │ ",
+ };
+
+ function isFullWidthCodePoint(code) {
+ // Code points are partially derived from:
+ // http://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
+ return (
+ code >= 0x1100 &&
+ (code <= 0x115f || // Hangul Jamo
+ code === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+ code === 0x232a || // RIGHT-POINTING ANGLE BRACKET
+ // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+ (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||
+ // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+ (code >= 0x3250 && code <= 0x4dbf) ||
+ // CJK Unified Ideographs .. Yi Radicals
+ (code >= 0x4e00 && code <= 0xa4c6) ||
+ // Hangul Jamo Extended-A
+ (code >= 0xa960 && code <= 0xa97c) ||
+ // Hangul Syllables
+ (code >= 0xac00 && code <= 0xd7a3) ||
+ // CJK Compatibility Ideographs
+ (code >= 0xf900 && code <= 0xfaff) ||
+ // Vertical Forms
+ (code >= 0xfe10 && code <= 0xfe19) ||
+ // CJK Compatibility Forms .. Small Form Variants
+ (code >= 0xfe30 && code <= 0xfe6b) ||
+ // Halfwidth and Fullwidth Forms
+ (code >= 0xff01 && code <= 0xff60) ||
+ (code >= 0xffe0 && code <= 0xffe6) ||
+ // Kana Supplement
+ (code >= 0x1b000 && code <= 0x1b001) ||
+ // Enclosed Ideographic Supplement
+ (code >= 0x1f200 && code <= 0x1f251) ||
+ // Miscellaneous Symbols and Pictographs 0x1f300 - 0x1f5ff
+ // Emoticons 0x1f600 - 0x1f64f
+ (code >= 0x1f300 && code <= 0x1f64f) ||
+ // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+ (code >= 0x20000 && code <= 0x3fffd))
+ );
+ }
+
+ function getStringWidth(str) {
+ str = stripColor(str).normalize("NFC");
+ let width = 0;
+
+ for (const ch of str) {
+ width += isFullWidthCodePoint(ch.codePointAt(0)) ? 2 : 1;
+ }
+
+ return width;
+ }
+
+ function renderRow(row, columnWidths) {
+ let out = tableChars.left;
+ for (let i = 0; i < row.length; i++) {
+ const cell = row[i];
+ const len = getStringWidth(cell);
+ const needed = (columnWidths[i] - len) / 2;
+ // round(needed) + ceil(needed) will always add up to the amount
+ // of spaces we need while also left justifying the output.
+ out += `${" ".repeat(needed)}${cell}${" ".repeat(Math.ceil(needed))}`;
+ if (i !== row.length - 1) {
+ out += tableChars.middle;
+ }
+ }
+ out += tableChars.right;
+ return out;
+ }
+
+ function cliTable(head, columns) {
+ const rows = [];
+ const columnWidths = head.map((h) => getStringWidth(h));
+ const longestColumn = columns.reduce(
+ (n, a) => Math.max(n, a.length),
+ 0,
+ );
+
+ for (let i = 0; i < head.length; i++) {
+ const column = columns[i];
+ for (let j = 0; j < longestColumn; j++) {
+ if (rows[j] === undefined) {
+ rows[j] = [];
+ }
+ const value = (rows[j][i] = hasOwnProperty(column, j) ? column[j] : "");
+ const width = columnWidths[i] || 0;
+ const counted = getStringWidth(value);
+ columnWidths[i] = Math.max(width, counted);
+ }
+ }
+
+ const divider = columnWidths.map((i) =>
+ tableChars.middleMiddle.repeat(i + 2)
+ );
+
+ let result = `${tableChars.topLeft}${divider.join(tableChars.topMiddle)}` +
+ `${tableChars.topRight}\n${renderRow(head, columnWidths)}\n` +
+ `${tableChars.leftMiddle}${divider.join(tableChars.rowMiddle)}` +
+ `${tableChars.rightMiddle}\n`;
+
+ for (const row of rows) {
+ result += `${renderRow(row, columnWidths)}\n`;
+ }
+
+ result +=
+ `${tableChars.bottomLeft}${divider.join(tableChars.bottomMiddle)}` +
+ tableChars.bottomRight;
+
+ return result;
+ }
+ /* End of forked part */
+
+ const DEFAULT_INSPECT_OPTIONS = {
+ depth: 4,
+ indentLevel: 0,
+ sorted: false,
+ trailingComma: false,
+ compact: true,
+ iterableLimit: 100,
+ };
+
+ const DEFAULT_INDENT = " "; // Default indent string
+
+ const LINE_BREAKING_LENGTH = 80;
+ const MIN_GROUP_LENGTH = 6;
+ const STR_ABBREVIATE_SIZE = 100;
+ // Char codes
+ const CHAR_PERCENT = 37; /* % */
+ const CHAR_LOWERCASE_S = 115; /* s */
+ const CHAR_LOWERCASE_D = 100; /* d */
+ const CHAR_LOWERCASE_I = 105; /* i */
+ const CHAR_LOWERCASE_F = 102; /* f */
+ const CHAR_LOWERCASE_O = 111; /* o */
+ const CHAR_UPPERCASE_O = 79; /* O */
+ const CHAR_LOWERCASE_C = 99; /* c */
+
+ const PROMISE_STRING_BASE_LENGTH = 12;
+
+ class CSI {
+ static kClear = "\x1b[1;1H";
+ static kClearScreenDown = "\x1b[0J";
+ }
+
+ /* eslint-disable @typescript-eslint/no-use-before-define */
+
+ function getClassInstanceName(instance) {
+ if (typeof instance !== "object") {
+ return "";
+ }
+ if (!instance) {
+ return "";
+ }
+
+ const proto = Object.getPrototypeOf(instance);
+ if (proto && proto.constructor) {
+ return proto.constructor.name; // could be "Object" or "Array"
+ }
+
+ return "";
+ }
+
+ function inspectFunction(value, _ctx) {
+ // Might be Function/AsyncFunction/GeneratorFunction
+ const cstrName = Object.getPrototypeOf(value).constructor.name;
+ if (value.name && value.name !== "anonymous") {
+ // from MDN spec
+ return `[${cstrName}: ${value.name}]`;
+ }
+ return `[${cstrName}]`;
+ }
+
+ function inspectIterable(
+ value,
+ ctx,
+ level,
+ options,
+ inspectOptions,
+ ) {
+ if (level >= inspectOptions.depth) {
+ return cyan(`[${options.typeName}]`);
+ }
+ ctx.add(value);
+
+ const entries = [];
+
+ const iter = value.entries();
+ let entriesLength = 0;
+ const next = () => {
+ return iter.next();
+ };
+ for (const el of iter) {
+ if (entriesLength < inspectOptions.iterableLimit) {
+ entries.push(
+ options.entryHandler(
+ el,
+ ctx,
+ level + 1,
+ inspectOptions,
+ next.bind(iter),
+ ),
+ );
+ }
+ entriesLength++;
+ }
+ ctx.delete(value);
+
+ if (options.sort) {
+ entries.sort();
+ }
+
+ if (entriesLength > inspectOptions.iterableLimit) {
+ const nmore = entriesLength - inspectOptions.iterableLimit;
+ entries.push(`... ${nmore} more items`);
+ }
+
+ const iPrefix = `${options.displayName ? options.displayName + " " : ""}`;
+
+ const initIndentation = `\n${DEFAULT_INDENT.repeat(level + 1)}`;
+ const entryIndentation = `,\n${DEFAULT_INDENT.repeat(level + 1)}`;
+ const closingIndentation = `${inspectOptions.trailingComma ? "," : ""}\n${
+ DEFAULT_INDENT.repeat(level)
+ }`;
+
+ let iContent;
+ if (options.group && entries.length > MIN_GROUP_LENGTH) {
+ const groups = groupEntries(entries, level, value);
+ iContent = `${initIndentation}${
+ groups.join(entryIndentation)
+ }${closingIndentation}`;
+ } else {
+ iContent = entries.length === 0 ? "" : ` ${entries.join(", ")} `;
+ if (
+ stripColor(iContent).length > LINE_BREAKING_LENGTH ||
+ !inspectOptions.compact
+ ) {
+ iContent = `${initIndentation}${
+ entries.join(entryIndentation)
+ }${closingIndentation}`;
+ }
+ }
+
+ return `${iPrefix}${options.delims[0]}${iContent}${options.delims[1]}`;
+ }
+
+ // Ported from Node.js
+ // Copyright Node.js contributors. All rights reserved.
+ function groupEntries(
+ entries,
+ level,
+ value,
+ iterableLimit = 100,
+ ) {
+ let totalLength = 0;
+ let maxLength = 0;
+ let entriesLength = entries.length;
+ if (iterableLimit < entriesLength) {
+ // This makes sure the "... n more items" part is not taken into account.
+ entriesLength--;
+ }
+ const separatorSpace = 2; // Add 1 for the space and 1 for the separator.
+ const dataLen = new Array(entriesLength);
+ // Calculate the total length of all output entries and the individual max
+ // entries length of all output entries.
+ // IN PROGRESS: Colors are being taken into account.
+ for (let i = 0; i < entriesLength; i++) {
+ // Taking colors into account: removing the ANSI color
+ // codes from the string before measuring its length
+ const len = stripColor(entries[i]).length;
+ dataLen[i] = len;
+ totalLength += len + separatorSpace;
+ if (maxLength < len) maxLength = len;
+ }
+ // Add two to `maxLength` as we add a single whitespace character plus a comma
+ // in-between two entries.
+ const actualMax = maxLength + separatorSpace;
+ // Check if at least three entries fit next to each other and prevent grouping
+ // of arrays that contains entries of very different length (i.e., if a single
+ // entry is longer than 1/5 of all other entries combined). Otherwise the
+ // space in-between small entries would be enormous.
+ if (
+ actualMax * 3 + (level + 1) < LINE_BREAKING_LENGTH &&
+ (totalLength / actualMax > 5 || maxLength <= 6)
+ ) {
+ const approxCharHeights = 2.5;
+ const averageBias = Math.sqrt(actualMax - totalLength / entries.length);
+ const biasedMax = Math.max(actualMax - 3 - averageBias, 1);
+ // Dynamically check how many columns seem possible.
+ const columns = Math.min(
+ // Ideally a square should be drawn. We expect a character to be about 2.5
+ // times as high as wide. This is the area formula to calculate a square
+ // which contains n rectangles of size `actualMax * approxCharHeights`.
+ // Divide that by `actualMax` to receive the correct number of columns.
+ // The added bias increases the columns for short entries.
+ Math.round(
+ Math.sqrt(approxCharHeights * biasedMax * entriesLength) / biasedMax,
+ ),
+ // Do not exceed the breakLength.
+ Math.floor((LINE_BREAKING_LENGTH - (level + 1)) / actualMax),
+ // Limit the columns to a maximum of fifteen.
+ 15,
+ );
+ // Return with the original output if no grouping should happen.
+ if (columns <= 1) {
+ return entries;
+ }
+ const tmp = [];
+ const maxLineLength = [];
+ for (let i = 0; i < columns; i++) {
+ let lineMaxLength = 0;
+ for (let j = i; j < entries.length; j += columns) {
+ if (dataLen[j] > lineMaxLength) lineMaxLength = dataLen[j];
+ }
+ lineMaxLength += separatorSpace;
+ maxLineLength[i] = lineMaxLength;
+ }
+ let order = "padStart";
+ if (value !== undefined) {
+ for (let i = 0; i < entries.length; i++) {
+ /* eslint-disable @typescript-eslint/no-explicit-any */
+ if (
+ typeof value[i] !== "number" &&
+ typeof value[i] !== "bigint"
+ ) {
+ order = "padEnd";
+ break;
+ }
+ /* eslint-enable */
+ }
+ }
+ // Each iteration creates a single line of grouped entries.
+ for (let i = 0; i < entriesLength; i += columns) {
+ // The last lines may contain less entries than columns.
+ const max = Math.min(i + columns, entriesLength);
+ let str = "";
+ let j = i;
+ for (; j < max - 1; j++) {
+ // In future, colors should be taken here into the account
+ const padding = maxLineLength[j - i];
+ str += `${entries[j]}, `[order](padding, " ");
+ }
+ if (order === "padStart") {
+ const padding = maxLineLength[j - i] +
+ entries[j].length -
+ dataLen[j] -
+ separatorSpace;
+ str += entries[j].padStart(padding, " ");
+ } else {
+ str += entries[j];
+ }
+ tmp.push(str);
+ }
+ if (iterableLimit < entries.length) {
+ tmp.push(entries[entriesLength]);
+ }
+ entries = tmp;
+ }
+ return entries;
+ }
+
+ function inspectValue(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ switch (typeof value) {
+ case "string":
+ return value;
+ case "number": // Numbers are yellow
+ // Special handling of -0
+ return yellow(Object.is(value, -0) ? "-0" : `${value}`);
+ case "boolean": // booleans are yellow
+ return yellow(String(value));
+ case "undefined": // undefined is dim
+ return dim(String(value));
+ case "symbol": // Symbols are green
+ return green(String(value));
+ case "bigint": // Bigints are yellow
+ return yellow(`${value}n`);
+ case "function": // Function string is cyan
+ return cyan(inspectFunction(value, ctx));
+ case "object": // null is bold
+ if (value === null) {
+ return bold("null");
+ }
+
+ if (ctx.has(value)) {
+ // Circular string is cyan
+ return cyan("[Circular]");
+ }
+
+ return inspectObject(value, ctx, level, inspectOptions);
+ default:
+ // Not implemented is red
+ return red("[Not Implemented]");
+ }
+ }
+
+ // We can match Node's quoting behavior exactly by swapping the double quote and
+ // single quote in this array. That would give preference to single quotes.
+ // However, we prefer double quotes as the default.
+ const QUOTES = ['"', "'", "`"];
+
+ /** Surround the string in quotes.
+ *
+ * The quote symbol is chosen by taking the first of the `QUOTES` array which
+ * does not occur in the string. If they all occur, settle with `QUOTES[0]`.
+ *
+ * Insert a backslash before any occurrence of the chosen quote symbol and
+ * before any backslash. */
+ function quoteString(string) {
+ const quote = QUOTES.find((c) => !string.includes(c)) ?? QUOTES[0];
+ const escapePattern = new RegExp(`(?=[${quote}\\\\])`, "g");
+ return `${quote}${string.replace(escapePattern, "\\")}${quote}`;
+ }
+
+ // Print strings when they are inside of arrays or objects with quotes
+ function inspectValueWithQuotes(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ switch (typeof value) {
+ case "string":
+ const trunc = value.length > STR_ABBREVIATE_SIZE
+ ? value.slice(0, STR_ABBREVIATE_SIZE) + "..."
+ : value;
+ return green(quoteString(trunc)); // Quoted strings are green
+ default:
+ return inspectValue(value, ctx, level, inspectOptions);
+ }
+ }
+
+ function inspectArray(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ const options = {
+ typeName: "Array",
+ displayName: "",
+ delims: ["[", "]"],
+ entryHandler: (entry, ctx, level, inspectOptions, next) => {
+ const [index, val] = entry;
+ let i = index;
+ if (!value.hasOwnProperty(i)) {
+ i++;
+ while (!value.hasOwnProperty(i) && i < value.length) {
+ next();
+ i++;
+ }
+ const emptyItems = i - index;
+ const ending = emptyItems > 1 ? "s" : "";
+ return dim(`<${emptyItems} empty item${ending}>`);
+ } else {
+ return inspectValueWithQuotes(val, ctx, level, inspectOptions);
+ }
+ },
+ group: inspectOptions.compact,
+ sort: false,
+ };
+ return inspectIterable(value, ctx, level, options, inspectOptions);
+ }
+
+ function inspectTypedArray(
+ typedArrayName,
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ const valueLength = value.length;
+ const options = {
+ typeName: typedArrayName,
+ displayName: `${typedArrayName}(${valueLength})`,
+ delims: ["[", "]"],
+ entryHandler: (entry, ctx, level, inspectOptions) => {
+ const val = entry[1];
+ return inspectValueWithQuotes(val, ctx, level + 1, inspectOptions);
+ },
+ group: inspectOptions.compact,
+ sort: false,
+ };
+ return inspectIterable(value, ctx, level, options, inspectOptions);
+ }
+
+ function inspectSet(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ const options = {
+ typeName: "Set",
+ displayName: "Set",
+ delims: ["{", "}"],
+ entryHandler: (entry, ctx, level, inspectOptions) => {
+ const val = entry[1];
+ return inspectValueWithQuotes(val, ctx, level + 1, inspectOptions);
+ },
+ group: false,
+ sort: inspectOptions.sorted,
+ };
+ return inspectIterable(value, ctx, level, options, inspectOptions);
+ }
+
+ function inspectMap(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ const options = {
+ typeName: "Map",
+ displayName: "Map",
+ delims: ["{", "}"],
+ entryHandler: (entry, ctx, level, inspectOptions) => {
+ const [key, val] = entry;
+ return `${
+ inspectValueWithQuotes(
+ key,
+ ctx,
+ level + 1,
+ inspectOptions,
+ )
+ } => ${inspectValueWithQuotes(val, ctx, level + 1, inspectOptions)}`;
+ },
+ group: false,
+ sort: inspectOptions.sorted,
+ };
+ return inspectIterable(
+ value,
+ ctx,
+ level,
+ options,
+ inspectOptions,
+ );
+ }
+
+ function inspectWeakSet() {
+ return `WeakSet { ${cyan("[items unknown]")} }`; // as seen in Node, with cyan color
+ }
+
+ function inspectWeakMap() {
+ return `WeakMap { ${cyan("[items unknown]")} }`; // as seen in Node, with cyan color
+ }
+
+ function inspectDate(value) {
+ // without quotes, ISO format, in magenta like before
+ return magenta(isInvalidDate(value) ? "Invalid Date" : value.toISOString());
+ }
+
+ function inspectRegExp(value) {
+ return red(value.toString()); // RegExps are red
+ }
+
+ function inspectStringObject(value) {
+ return cyan(`[String: "${value.toString()}"]`); // wrappers are in cyan
+ }
+
+ function inspectBooleanObject(value) {
+ return cyan(`[Boolean: ${value.toString()}]`); // wrappers are in cyan
+ }
+
+ function inspectNumberObject(value) {
+ return cyan(`[Number: ${value.toString()}]`); // wrappers are in cyan
+ }
+
+ const PromiseState = {
+ Pending: 0,
+ Fulfilled: 1,
+ Rejected: 2,
+ };
+
+ function inspectPromise(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ const [state, result] = Deno.core.getPromiseDetails(value);
+
+ if (state === PromiseState.Pending) {
+ return `Promise { ${cyan("<pending>")} }`;
+ }
+
+ const prefix = state === PromiseState.Fulfilled
+ ? ""
+ : `${red("<rejected>")} `;
+
+ const str = `${prefix}${
+ inspectValueWithQuotes(
+ result,
+ ctx,
+ level + 1,
+ inspectOptions,
+ )
+ }`;
+
+ if (str.length + PROMISE_STRING_BASE_LENGTH > LINE_BREAKING_LENGTH) {
+ return `Promise {\n${DEFAULT_INDENT.repeat(level + 1)}${str}\n}`;
+ }
+
+ return `Promise { ${str} }`;
+ }
+
+ // TODO: Proxy
+
+ function inspectRawObject(
+ value,
+ ctx,
+ level,
+ inspectOptions,
+ ) {
+ if (level >= inspectOptions.depth) {
+ return cyan("[Object]"); // wrappers are in cyan
+ }
+ ctx.add(value);
+
+ let baseString;
+
+ let shouldShowDisplayName = false;
+ let displayName = value[
+ Symbol.toStringTag
+ ];
+ if (!displayName) {
+ displayName = getClassInstanceName(value);
+ }
+ if (
+ displayName && displayName !== "Object" && displayName !== "anonymous"
+ ) {
+ shouldShowDisplayName = true;
+ }
+
+ const entries = [];
+ const stringKeys = Object.keys(value);
+ const symbolKeys = Object.getOwnPropertySymbols(value);
+ if (inspectOptions.sorted) {
+ stringKeys.sort();
+ symbolKeys.sort((s1, s2) =>
+ (s1.description ?? "").localeCompare(s2.description ?? "")
+ );
+ }
+
+ for (const key of stringKeys) {
+ entries.push(
+ `${key}: ${
+ inspectValueWithQuotes(
+ value[key],
+ ctx,
+ level + 1,
+ inspectOptions,
+ )
+ }`,
+ );
+ }
+ for (const key of symbolKeys) {
+ entries.push(
+ `${key.toString()}: ${
+ inspectValueWithQuotes(
+ value[key],
+ ctx,
+ level + 1,
+ inspectOptions,
+ )
+ }`,
+ );
+ }
+ // Making sure color codes are ignored when calculating the total length
+ const totalLength = entries.length + level +
+ stripColor(entries.join("")).length;
+
+ ctx.delete(value);
+
+ if (entries.length === 0) {
+ baseString = "{}";
+ } else if (totalLength > LINE_BREAKING_LENGTH || !inspectOptions.compact) {
+ const entryIndent = DEFAULT_INDENT.repeat(level + 1);
+ const closingIndent = DEFAULT_INDENT.repeat(level);
+ baseString = `{\n${entryIndent}${entries.join(`,\n${entryIndent}`)}${
+ inspectOptions.trailingComma ? "," : ""
+ }\n${closingIndent}}`;
+ } else {
+ baseString = `{ ${entries.join(", ")} }`;
+ }
+
+ if (shouldShowDisplayName) {
+ baseString = `${displayName} ${baseString}`;
+ }
+
+ return baseString;
+ }
+
+ function inspectObject(
+ value,
+ consoleContext,
+ level,
+ inspectOptions,
+ ) {
+ if (customInspect in value && typeof value[customInspect] === "function") {
+ try {
+ return String(value[customInspect]());
+ } catch {}
+ }
+ if (value instanceof Error) {
+ return String(value.stack);
+ } else if (Array.isArray(value)) {
+ return inspectArray(value, consoleContext, level, inspectOptions);
+ } else if (value instanceof Number) {
+ return inspectNumberObject(value);
+ } else if (value instanceof Boolean) {
+ return inspectBooleanObject(value);
+ } else if (value instanceof String) {
+ return inspectStringObject(value);
+ } else if (value instanceof Promise) {
+ return inspectPromise(value, consoleContext, level, inspectOptions);
+ } else if (value instanceof RegExp) {
+ return inspectRegExp(value);
+ } else if (value instanceof Date) {
+ return inspectDate(value);
+ } else if (value instanceof Set) {
+ return inspectSet(value, consoleContext, level, inspectOptions);
+ } else if (value instanceof Map) {
+ return inspectMap(value, consoleContext, level, inspectOptions);
+ } else if (value instanceof WeakSet) {
+ return inspectWeakSet();
+ } else if (value instanceof WeakMap) {
+ return inspectWeakMap();
+ } else if (isTypedArray(value)) {
+ return inspectTypedArray(
+ Object.getPrototypeOf(value).constructor.name,
+ value,
+ consoleContext,
+ level,
+ inspectOptions,
+ );
+ } else {
+ // Otherwise, default object formatting
+ return inspectRawObject(value, consoleContext, level, inspectOptions);
+ }
+ }
+
+ function inspectArgs(
+ args,
+ inspectOptions = {},
+ ) {
+ const rInspectOptions = { ...DEFAULT_INSPECT_OPTIONS, ...inspectOptions };
+ const first = args[0];
+ let a = 0;
+ let str = "";
+ let join = "";
+
+ if (typeof first === "string") {
+ let tempStr;
+ let lastPos = 0;
+
+ for (let i = 0; i < first.length - 1; i++) {
+ if (first.charCodeAt(i) === CHAR_PERCENT) {
+ const nextChar = first.charCodeAt(++i);
+ if (a + 1 !== args.length) {
+ switch (nextChar) {
+ case CHAR_LOWERCASE_S:
+ // format as a string
+ tempStr = String(args[++a]);
+ break;
+ case CHAR_LOWERCASE_D:
+ case CHAR_LOWERCASE_I:
+ // format as an integer
+ const tempInteger = args[++a];
+ if (typeof tempInteger === "bigint") {
+ tempStr = `${tempInteger}n`;
+ } else if (typeof tempInteger === "symbol") {
+ tempStr = "NaN";
+ } else {
+ tempStr = `${parseInt(String(tempInteger), 10)}`;
+ }
+ break;
+ case CHAR_LOWERCASE_F:
+ // format as a floating point value
+ const tempFloat = args[++a];
+ if (typeof tempFloat === "symbol") {
+ tempStr = "NaN";
+ } else {
+ tempStr = `${parseFloat(String(tempFloat))}`;
+ }
+ break;
+ case CHAR_LOWERCASE_O:
+ case CHAR_UPPERCASE_O:
+ // format as an object
+ tempStr = inspectValue(
+ args[++a],
+ new Set(),
+ 0,
+ rInspectOptions,
+ );
+ break;
+ case CHAR_PERCENT:
+ str += first.slice(lastPos, i);
+ lastPos = i + 1;
+ continue;
+ case CHAR_LOWERCASE_C:
+ // TODO: applies CSS style rules to the output string as specified
+ continue;
+ default:
+ // any other character is not a correct placeholder
+ continue;
+ }
+
+ if (lastPos !== i - 1) {
+ str += first.slice(lastPos, i - 1);
+ }
+
+ str += tempStr;
+ lastPos = i + 1;
+ } else if (nextChar === CHAR_PERCENT) {
+ str += first.slice(lastPos, i);
+ lastPos = i + 1;
+ }
+ }
+ }
+
+ if (lastPos !== 0) {
+ a++;
+ join = " ";
+ if (lastPos < first.length) {
+ str += first.slice(lastPos);
+ }
+ }
+ }
+
+ while (a < args.length) {
+ const value = args[a];
+ str += join;
+ if (typeof value === "string") {
+ str += value;
+ } else {
+ // use default maximum depth for null or undefined argument
+ str += inspectValue(value, new Set(), 0, rInspectOptions);
+ }
+ join = " ";
+ a++;
+ }
+
+ if (rInspectOptions.indentLevel > 0) {
+ const groupIndent = DEFAULT_INDENT.repeat(rInspectOptions.indentLevel);
+ if (str.indexOf("\n") !== -1) {
+ str = str.replace(/\n/g, `\n${groupIndent}`);
+ }
+ str = groupIndent + str;
+ }
+
+ return str;
+ }
+
+ const countMap = new Map();
+ const timerMap = new Map();
+ const isConsoleInstance = Symbol("isConsoleInstance");
+
+ class Console {
+ #printFunc = null;
+ [isConsoleInstance] = false;
+
+ constructor(printFunc) {
+ this.#printFunc = printFunc;
+ this.indentLevel = 0;
+ this[isConsoleInstance] = true;
+
+ // ref https://console.spec.whatwg.org/#console-namespace
+ // For historical web-compatibility reasons, the namespace object for
+ // console must have as its [[Prototype]] an empty object, created as if
+ // by ObjectCreate(%ObjectPrototype%), instead of %ObjectPrototype%.
+ const console = Object.create({});
+ Object.assign(console, this);
+ return console;
+ }
+
+ log = (...args) => {
+ this.#printFunc(
+ inspectArgs(args, {
+ indentLevel: this.indentLevel,
+ }) + "\n",
+ false,
+ );
+ };
+
+ debug = this.log;
+ info = this.log;
+
+ dir = (obj, options = {}) => {
+ this.#printFunc(inspectArgs([obj], options) + "\n", false);
+ };
+
+ dirxml = this.dir;
+
+ warn = (...args) => {
+ this.#printFunc(
+ inspectArgs(args, {
+ indentLevel: this.indentLevel,
+ }) + "\n",
+ true,
+ );
+ };
+
+ error = this.warn;
+
+ assert = (condition = false, ...args) => {
+ if (condition) {
+ return;
+ }
+
+ if (args.length === 0) {
+ this.error("Assertion failed");
+ return;
+ }
+
+ const [first, ...rest] = args;
+
+ if (typeof first === "string") {
+ this.error(`Assertion failed: ${first}`, ...rest);
+ return;
+ }
+
+ this.error(`Assertion failed:`, ...args);
+ };
+
+ count = (label = "default") => {
+ label = String(label);
+
+ if (countMap.has(label)) {
+ const current = countMap.get(label) || 0;
+ countMap.set(label, current + 1);
+ } else {
+ countMap.set(label, 1);
+ }
+
+ this.info(`${label}: ${countMap.get(label)}`);
+ };
+
+ countReset = (label = "default") => {
+ label = String(label);
+
+ if (countMap.has(label)) {
+ countMap.set(label, 0);
+ } else {
+ this.warn(`Count for '${label}' does not exist`);
+ }
+ };
+
+ table = (data, properties) => {
+ if (properties !== undefined && !Array.isArray(properties)) {
+ throw new Error(
+ "The 'properties' argument must be of type Array. " +
+ "Received type string",
+ );
+ }
+
+ if (data === null || typeof data !== "object") {
+ return this.log(data);
+ }
+
+ const objectValues = {};
+ const indexKeys = [];
+ const values = [];
+
+ const stringifyValue = (value) =>
+ inspectValueWithQuotes(value, new Set(), 0, {
+ ...DEFAULT_INSPECT_OPTIONS,
+ depth: 1,
+ });
+ const toTable = (header, body) => this.log(cliTable(header, body));
+ const createColumn = (value, shift) => [
+ ...(shift ? [...new Array(shift)].map(() => "") : []),
+ stringifyValue(value),
+ ];
+
+ let resultData;
+ const isSet = data instanceof Set;
+ const isMap = data instanceof Map;
+ const valuesKey = "Values";
+ const indexKey = isSet || isMap ? "(iter idx)" : "(idx)";
+
+ if (data instanceof Set) {
+ resultData = [...data];
+ } else if (data instanceof Map) {
+ let idx = 0;
+ resultData = {};
+
+ data.forEach((v, k) => {
+ resultData[idx] = { Key: k, Values: v };
+ idx++;
+ });
+ } else {
+ resultData = data;
+ }
+
+ let hasPrimitives = false;
+ Object.keys(resultData).forEach((k, idx) => {
+ const value = resultData[k];
+ const primitive = value === null ||
+ (typeof value !== "function" && typeof value !== "object");
+ if (properties === undefined && primitive) {
+ hasPrimitives = true;
+ values.push(stringifyValue(value));
+ } else {
+ const valueObj = value || {};
+ const keys = properties || Object.keys(valueObj);
+ for (const k of keys) {
+ if (primitive || !valueObj.hasOwnProperty(k)) {
+ if (objectValues[k]) {
+ // fill with blanks for idx to avoid misplacing from later values
+ objectValues[k].push("");
+ }
+ } else {
+ if (objectValues[k]) {
+ objectValues[k].push(stringifyValue(valueObj[k]));
+ } else {
+ objectValues[k] = createColumn(valueObj[k], idx);
+ }
+ }
+ }
+ values.push("");
+ }
+
+ indexKeys.push(k);
+ });
+
+ const headerKeys = Object.keys(objectValues);
+ const bodyValues = Object.values(objectValues);
+ const header = [
+ indexKey,
+ ...(properties ||
+ [...headerKeys, !isMap && hasPrimitives && valuesKey]),
+ ].filter(Boolean);
+ const body = [indexKeys, ...bodyValues, values];
+
+ toTable(header, body);
+ };
+
+ time = (label = "default") => {
+ label = String(label);
+
+ if (timerMap.has(label)) {
+ this.warn(`Timer '${label}' already exists`);
+ return;
+ }
+
+ timerMap.set(label, Date.now());
+ };
+
+ timeLog = (label = "default", ...args) => {
+ label = String(label);
+
+ if (!timerMap.has(label)) {
+ this.warn(`Timer '${label}' does not exists`);
+ return;
+ }
+
+ const startTime = timerMap.get(label);
+ const duration = Date.now() - startTime;
+
+ this.info(`${label}: ${duration}ms`, ...args);
+ };
+
+ timeEnd = (label = "default") => {
+ label = String(label);
+
+ if (!timerMap.has(label)) {
+ this.warn(`Timer '${label}' does not exists`);
+ return;
+ }
+
+ const startTime = timerMap.get(label);
+ timerMap.delete(label);
+ const duration = Date.now() - startTime;
+
+ this.info(`${label}: ${duration}ms`);
+ };
+
+ group = (...label) => {
+ if (label.length > 0) {
+ this.log(...label);
+ }
+ this.indentLevel += 2;
+ };
+
+ groupCollapsed = this.group;
+
+ groupEnd = () => {
+ if (this.indentLevel > 0) {
+ this.indentLevel -= 2;
+ }
+ };
+
+ clear = () => {
+ this.indentLevel = 0;
+ this.#printFunc(CSI.kClear, false);
+ this.#printFunc(CSI.kClearScreenDown, false);
+ };
+
+ trace = (...args) => {
+ const message = inspectArgs(args, { indentLevel: 0 });
+ const err = {
+ name: "Trace",
+ message,
+ };
+ Error.captureStackTrace(err, this.trace);
+ this.error(err.stack);
+ };
+
+ static [Symbol.hasInstance](instance) {
+ return instance[isConsoleInstance];
+ }
+ }
+
+ const customInspect = Symbol("Deno.customInspect");
+
+ function inspect(
+ value,
+ inspectOptions = {},
+ ) {
+ if (typeof value === "string") {
+ return value;
+ } else {
+ return inspectValue(value, new Set(), 0, {
+ ...DEFAULT_INSPECT_OPTIONS,
+ ...inspectOptions,
+ // TODO(nayeemrmn): Indent level is not supported.
+ indentLevel: 0,
+ });
+ }
+ }
+
+ // Expose these fields to internalObject for tests.
+ exposeForTest("Console", Console);
+ exposeForTest("inspectArgs", inspectArgs);
+
+ window.__bootstrap.console = {
+ CSI,
+ inspectArgs,
+ Console,
+ customInspect,
+ inspect,
+ };
+})(this);
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-28 06:17:26 +0000