visaljs 0.0.9 → 0.0.11

package/node/prelude/console.js

@@ -1,38 +1,44 @@
-// node:console: the global console (the runtime's, in C), and Console, a console writing to the
-// streams it's given, as Node's: log, info, debug and dirxml to stdout; warn, error and trace to
-// stderr; groups indent every line; count, time and table as Node formats them. Its formatting is
-// util.format's and util.inspect's, which the global console's is too.
-import { inspect, format, formatWithOptions, stripVTControlCharacters } from "./util.js";
-import { codeError, invalidArgType } from "./internal/errors.js";
+// node:console (Node's lib/internal/console/constructor.js and internal/cli_table.js): Console, a
+// console writing to the streams it's given. The global console is the runtime's (in C), writing
+// to the fds; a program that replaces a stdio stream's write gets Node's instead
+// (internal/console_global.js, over this module's Console).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { previewEntries } from "visaljs:host";
+import { channel } from "./diagnostics_channel.js";
+import { codeError, invalidArgType, invalidArgValue, outOfRange } from "./internal/errors.js";
+import { getStringWidth } from "./internal/string_width.js";
+import { formatWithOptions, inspect } from "./util.js";
+import { isMap, isMapIterator, isSet, isSetIterator, isTypedArray } from "./util_types.js";
 
-const kIsConsole = Symbol("kIsConsole");
 const kSecond = 1000;
 const kMinute = 60 * kSecond;
 const kHour = 60 * kMinute;
 
-/* ---- console.table: Node's internal/cli_table ------------------------------------------------- */
-
-const isFullWidthCodePoint = (code) => code >= 0x1100 && (code <= 0x115f || code === 0x2329 || code === 0x232a ||
-  (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) || (code >= 0x3250 && code <= 0x4dbf) || (code >= 0x4e00 && code <= 0xa4c6) ||
-  (code >= 0xa960 && code <= 0xa97c) || (code >= 0xac00 && code <= 0xd7a3) || (code >= 0xf900 && code <= 0xfaff) ||
-  (code >= 0xfe10 && code <= 0xfe19) || (code >= 0xfe30 && code <= 0xfe6b) || (code >= 0xff01 && code <= 0xff60) ||
-  (code >= 0xffe0 && code <= 0xffe6) || (code >= 0x1b000 && code <= 0x1b001) || (code >= 0x1f200 && code <= 0x1f251) ||
-  (code >= 0x1f300 && code <= 0x1f64f) || (code >= 0x20000 && code <= 0x3fffd));
-
-const isZeroWidthCodePoint = (code) => code <= 0x1f || (code >= 0x7f && code <= 0x9f) || (code >= 0x300 && code <= 0x36f) ||
-  (code >= 0x200b && code <= 0x200f) || (code >= 0x20d0 && code <= 0x20ff) || (code >= 0xfe00 && code <= 0xfe0f) ||
-  (code >= 0xfe20 && code <= 0xfe2f) || (code >= 0xe0100 && code <= 0xe01ef);
-
-/* columns on a terminal: wide characters two, combining ones none */
-function getStringWidth(str) {
-  let width = 0;
-  for (const char of stripVTControlCharacters(str).normalize("NFC")) {
-    const code = char.codePointAt(0);
-    if (isFullWidthCodePoint(code)) width += 2;
-    else if (!isZeroWidthCodePoint(code)) width++;
-  }
-  return width;
-}
+const onLog = channel("console.log");
+const onWarn = channel("console.warn");
+const onError = channel("console.error");
+const onInfo = channel("console.info");
+const onDebug = channel("console.debug");
+
+const kMaxGroupIndentation = 1000;
+const kCounts = Symbol("counts");
+const kGroupIndentationWidth = Symbol("kGroupIndentWidth");
+const kFormatForStderr = Symbol("kFormatForStderr");
+const kFormatForStdout = Symbol("kFormatForStdout");
+const kGetInspectOptions = Symbol("kGetInspectOptions");
+const kColorMode = Symbol("kColorMode");
+const kIsConsole = Symbol("kIsConsole");
+const kWriteToConsole = Symbol("kWriteToConsole");
+export const kBindProperties = Symbol("kBindProperties");
+const kBindStreamsEager = Symbol("kBindStreamsEager");
+export const kBindStreamsLazy = Symbol("kBindStreamsLazy");
+const kUseStdout = Symbol("kUseStdout");
+const kUseStderr = Symbol("kUseStderr");
+const kGroupIndentationString = Symbol("kGroupIndentationString");
+
+const optionsMap = new WeakMap();
+
+/* ---- console.table (Node's internal/cli_table.js) ------------------------------------------- */
 
 const tableChars = {
   middleMiddle: "─", rowMiddle: "┼", topRight: "┐", topLeft: "┌", leftMiddle: "├", topMiddle: "┬", bottomRight: "┘",
@@ -43,13 +49,14 @@ function renderRow(row, columnWidths) {
   let out = tableChars.left;
   for (let i = 0; i < row.length; i++) {
     const cell = row[i];
-    out += cell + " ".repeat(columnWidths[i] - getStringWidth(cell));  /* left-aligned, as Node 22's */
+    const needed = columnWidths[i] - getStringWidth(cell);
+    out += cell + " ".repeat(Math.ceil(needed));
     if (i !== row.length - 1) out += tableChars.middle;
   }
   return out + tableChars.right;
 }
 
-function renderTable(head, columns) {
+function cliTable(head, columns) {
   const rows = [];
   const columnWidths = head.map((h) => getStringWidth(h));
   const longestColumn = Math.max(...columns.map((a) => a.length));
@@ -57,17 +64,19 @@ function renderTable(head, columns) {
     const column = columns[i];
     for (let j = 0; j < longestColumn; j++) {
       if (rows[j] === undefined) rows[j] = [];
-      const value = (rows[j][i] = Object.hasOwn(column, j) ? column[j] : "");
+      const value = rows[j][i] = Object.hasOwn(column, j) ? column[j] : "";
       columnWidths[i] = Math.max(columnWidths[i] || 0, getStringWidth(value));
     }
   }
-  const divider = columnWidths.map((w) => tableChars.middleMiddle.repeat(w + 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";
+  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`;
   return result + tableChars.bottomLeft + divider.join(tableChars.bottomMiddle) + tableChars.bottomRight;
 }
 
+/* ---- console.time (Node's internal/util/debuglog.js) --------------------------------------- */
+
 /* "1.234ms", "1.500s", "1:02.345 (m:ss.mmm)", "1:02:03.456 (h:mm:ss.mmm)" */
 function formatTime(ms) {
   let hours = 0;
@@ -99,87 +108,231 @@ const now = () => {
   return s * 1e3 + ns / 1e6;
 };
 
+function timeLogImpl(console, label, implementation, data) {
+  const start = console._times.get(label);
+  if (start === undefined) {
+    process.emitWarning(`No such label '${label}' for ${implementation}`);
+    return false;
+  }
+  console.log("%s: %s", label, formatTime(now() - start), ...(data ?? []));
+  return true;
+}
+
+/* ---- colors (Node's internal/util/colors.js shouldColorize) --------------------------------- */
+
+/* Node's FORCE_COLOR levels (tty's getColorDepth): '', 1, true, 2 and 3 give colors */
+const FORCE_COLORS = new Set(["", "1", "true", "2", "3"]);
+
+function shouldColorize(stream) {
+  if (process.env.FORCE_COLOR !== undefined) return FORCE_COLORS.has(process.env.FORCE_COLOR);
+  return Boolean(stream?.isTTY) && (typeof stream.getColorDepth === "function" ? stream.getColorDepth() > 2 : true);
+}
+
 /* ---- Console ---------------------------------------------------------------------------------- */
 
-/** Console(stdout[, stderr[, ignoreErrors]]) or Console({ stdout, stderr, ignoreErrors,
- *  colorMode, inspectOptions, groupIndentation }). Callable without new, as Node's; its methods
- *  are bound, so they can be passed around. */
-export function Console(options, stderr, ignoreErrors) {
-  if (!new.target) return Reflect.construct(Console, [options, stderr, ignoreErrors]);
-  if (!options || typeof options.write === "function") options = { stdout: options, stderr, ignoreErrors };
-  const { stdout, ignoreErrors: ignore = true, colorMode = "auto", inspectOptions, groupIndentation = 2 } = options;
-  const err = options.stderr || stdout;
-  if (!stdout || typeof stdout.write !== "function") throw codeError(TypeError, "ERR_CONSOLE_WRITABLE_STREAM", "Console expects a writable stream instance for stdout");
-  if (!err || typeof err.write !== "function") throw codeError(TypeError, "ERR_CONSOLE_WRITABLE_STREAM", "Console expects a writable stream instance for stderr");
-  if (typeof colorMode !== "boolean" && colorMode !== "auto") {
-    throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", `The argument 'colorMode' is invalid. Received ${inspect(colorMode)}`);
+/** Console(stdout[, stderr[, ignoreErrors]]) or Console({ stdout, stderr, ignoreErrors, colorMode,
+ *  inspectOptions, groupIndentation }); callable without new; its methods bound, so they can be
+ *  passed around */
+export function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
+  if (new.target === undefined) return Reflect.construct(Console, arguments);
+  if (!options || typeof options.write === "function") options = { stdout: options, stderr: arguments[1], ignoreErrors: arguments[2] };
+  const { stdout, stderr = stdout, ignoreErrors = true, colorMode = "auto", inspectOptions, groupIndentation } = options;
+  if (!stdout || typeof stdout.write !== "function") {
+    throw codeError(TypeError, "ERR_CONSOLE_WRITABLE_STREAM", "Console expects a writable stream instance for stdout");
+  }
+  if (!stderr || typeof stderr.write !== "function") {
+    throw codeError(TypeError, "ERR_CONSOLE_WRITABLE_STREAM", "Console expects a writable stream instance for stderr");
   }
-  if (typeof groupIndentation !== "number" || !Number.isInteger(groupIndentation) || groupIndentation < 0 || groupIndentation > 1000) {
-    throw codeError(RangeError, "ERR_OUT_OF_RANGE", `The value of "groupIndentation" is out of range. It must be >= 0 && <= 1000. Received ${groupIndentation}`);
+  if (colorMode !== "auto" && colorMode !== true && colorMode !== false) {
+    throw invalidArgValue("colorMode", "must be one of: 'auto', true, false", colorMode);
   }
-  if (inspectOptions !== undefined && (inspectOptions === null || typeof inspectOptions !== "object")) {
-    throw invalidArgType("options.inspectOptions", "of type object", inspectOptions);
+  if (groupIndentation !== undefined) {
+    if (typeof groupIndentation !== "number") throw invalidArgType("groupIndentation", "of type number", groupIndentation);
+    if (!Number.isInteger(groupIndentation)) throw outOfRange("groupIndentation", "an integer", groupIndentation);
+    if (groupIndentation < 0 || groupIndentation > kMaxGroupIndentation) {
+      throw outOfRange("groupIndentation", `>= 0 && <= ${kMaxGroupIndentation}`, groupIndentation);
+    }
   }
-  if (inspectOptions?.colors !== undefined && colorMode !== "auto") {
-    throw codeError(TypeError, "ERR_INCOMPATIBLE_OPTION_PAIR", 'Option "options.inspectOptions.color" cannot be used in combination with option "colorMode"');
+  if (inspectOptions !== undefined) {
+    if (inspectOptions === null || typeof inspectOptions !== "object" || Array.isArray(inspectOptions)) {
+      throw invalidArgType("options.inspectOptions", "of type object", inspectOptions);
+    }
+    /* one set of options for both streams, or a Map from a stream to its own */
+    const inspectOptionsMap = isMap(inspectOptions) ? inspectOptions : new Map([[stdout, inspectOptions], [stderr, inspectOptions]]);
+    for (const streamOptions of inspectOptionsMap.values()) {
+      if (streamOptions.colors !== undefined && options.colorMode !== undefined) {
+        throw codeError(TypeError, "ERR_INCOMPATIBLE_OPTION_PAIR", 'Option "options.inspectOptions.color" cannot be used in combination with option "colorMode"');
+      }
+    }
+    optionsMap.set(this, inspectOptionsMap);
   }
-  Object.defineProperties(this, {
-    _stdout: { value: stdout, writable: true, configurable: true },
-    _stderr: { value: err, writable: true, configurable: true },
-    _ignoreErrors: { value: Boolean(ignore), writable: true, configurable: true },
-  });
-  this[kIsConsole] = true;
-  this._colorMode = colorMode;
-  this._inspectOptions = inspectOptions;
-  this._groupIndent = "";
-  this._groupIndentation = groupIndentation;
-  this._counts = new Map();
-  this._times = new Map();
-  /* bound, as Node's: const { log } = console works */
+  /* bound, as Node's: const { log } = console works; a subclass's methods are the ones bound */
   for (const key of Object.keys(Console.prototype)) {
-    this[key] = Console.prototype[key].bind(this);
+    this[key] = this[key].bind(this);
     Object.defineProperty(this[key], "name", { value: key });
   }
+  this[kBindStreamsEager](stdout, stderr);
+  this[kBindProperties](ignoreErrors, colorMode, groupIndentation);
 }
 
+const consolePropAttributes = { writable: true, enumerable: false, configurable: true };
+
 Object.defineProperty(Console, Symbol.hasInstance, {
-  value: (instance) => instance === globalThis.console || Boolean(instance?.[kIsConsole]),
+  value: function (instance) {
+    return instance?.[kIsConsole] === true || instance === globalThis.console;
+  },
 });
 
-const proto = Console.prototype;
+const kColorInspectOptions = { colors: true };
+const kNoColorInspectOptions = {};
 
-/* a line to a stream: indented by the groups, write errors ignored unless asked not to */
-proto._write = function (useStderr, string) {
-  const stream = useStderr ? this._stderr : this._stdout;
-  if (this._groupIndent.length !== 0) {
-    if (string.includes("\n")) string = string.replaceAll("\n", `\n${this._groupIndent}`);
-    string = this._groupIndent + string;
-  }
-  string += "\n";
-  if (!this._ignoreErrors) return stream.write(string);
-  try {
-    if (typeof stream.listenerCount === "function" && stream.listenerCount("error") === 0) stream.once("error", () => {});
-    stream.write(string, () => {});
-  } catch {
-    /* the console doesn't throw for its stream */
-  }
-};
-Object.defineProperty(proto, "_write", { enumerable: false });
+function noop() {}
 
-proto._format = function (args) {
-  return this._inspectOptions ? formatWithOptions(this._inspectOptions, ...args) : format(...args);
-};
-Object.defineProperty(proto, "_format", { enumerable: false });
+function createWriteErrorHandler(instance, streamSymbol) {
+  return (err) => {
+    /* the stream's 'error' listener that write() adds: kept until the error is emitted */
+    const stream = streamSymbol === kUseStdout ? instance._stdout : instance._stderr;
+    if (err !== null && !stream._writableState?.errorEmitted) {
+      if (stream.listenerCount?.("error") === 0) stream.once("error", noop);
+    }
+  };
+}
 
-Object.assign(proto, {
+const isStackOverflowError = (e) => e instanceof RangeError && e.message === "Maximum call stack size exceeded";
+
+Object.defineProperties(Console.prototype, {
+  [kBindStreamsEager]: {
+    ...consolePropAttributes,
+    value: function (stdout, stderr) {
+      Object.defineProperties(this, {
+        _stdout: { ...consolePropAttributes, value: stdout },
+        _stderr: { ...consolePropAttributes, value: stderr },
+      });
+    },
+  },
+  /* the global console's: process.stdout and process.stderr, looked up when first written */
+  [kBindStreamsLazy]: {
+    ...consolePropAttributes,
+    value: function (object) {
+      let stdout;
+      let stderr;
+      Object.defineProperties(this, {
+        _stdout: {
+          enumerable: false,
+          configurable: true,
+          get() { return stdout ||= object.stdout; },
+          set(value) { stdout = value; },
+        },
+        _stderr: {
+          enumerable: false,
+          configurable: true,
+          get() { return stderr ||= object.stderr; },
+          set(value) { stderr = value; },
+        },
+      });
+    },
+  },
+  [kBindProperties]: {
+    ...consolePropAttributes,
+    value: function (ignoreErrors, colorMode, groupIndentation = 2) {
+      Object.defineProperties(this, {
+        _stdoutErrorHandler: { ...consolePropAttributes, value: createWriteErrorHandler(this, kUseStdout) },
+        _stderrErrorHandler: { ...consolePropAttributes, value: createWriteErrorHandler(this, kUseStderr) },
+        _ignoreErrors: { ...consolePropAttributes, value: Boolean(ignoreErrors) },
+        _times: { ...consolePropAttributes, value: new Map() },
+        [kCounts]: { ...consolePropAttributes, value: new Map() },
+        [kColorMode]: { ...consolePropAttributes, value: colorMode },
+        [kIsConsole]: { ...consolePropAttributes, value: true },
+        [kGroupIndentationWidth]: { ...consolePropAttributes, value: groupIndentation },
+        [kGroupIndentationString]: { ...consolePropAttributes, value: "" },
+        [Symbol.toStringTag]: { writable: false, enumerable: false, configurable: true, value: "console" },
+      });
+    },
+  },
+  [kWriteToConsole]: {
+    ...consolePropAttributes,
+    value: function (streamSymbol, string) {
+      const ignoreErrors = this._ignoreErrors;
+      const groupIndent = this[kGroupIndentationString];
+      const useStdout = streamSymbol === kUseStdout;
+      const stream = useStdout ? this._stdout : this._stderr;
+      const errorHandler = useStdout ? this._stdoutErrorHandler : this._stderrErrorHandler;
+      if (groupIndent.length !== 0) {
+        if (string.includes("\n")) string = string.replace(/\n/g, `\n${groupIndent}`);
+        string = groupIndent + string;
+      }
+      string += "\n";
+      if (ignoreErrors === false) return stream.write(string);
+      /* errors ignored, but for a stack overflow (Node's), which the program should see */
+      try {
+        if (stream.listenerCount?.("error") === 0) stream.once("error", noop);
+        stream.write(string, errorHandler);
+      } catch (e) {
+        if (isStackOverflowError(e)) throw e;
+      } finally {
+        stream.removeListener?.("error", noop);
+      }
+    },
+  },
+  [kGetInspectOptions]: {
+    ...consolePropAttributes,
+    value: function (stream) {
+      let color = this[kColorMode];
+      if (color === "auto") color = shouldColorize(stream);
+      const options = optionsMap.get(this)?.get(stream);
+      if (options) {
+        if (options.colors === undefined) options.colors = color;
+        return options;
+      }
+      return color ? kColorInspectOptions : kNoColorInspectOptions;
+    },
+  },
+  [kFormatForStdout]: {
+    ...consolePropAttributes,
+    value: function (args) {
+      if (args.length === 1 && typeof args[0] === "string") return args[0];
+      return formatWithOptions(this[kGetInspectOptions](this._stdout), ...args);
+    },
+  },
+  [kFormatForStderr]: {
+    ...consolePropAttributes,
+    value: function (args) {
+      if (args.length === 1 && typeof args[0] === "string") return args[0];
+      return formatWithOptions(this[kGetInspectOptions](this._stderr), ...args);
+    },
+  },
+});
+
+const keyKey = "Key";
+const valuesKey = "Values";
+const indexKey = "(index)";
+const iterKey = "(iteration index)";
+
+const isArray = (v) => Array.isArray(v) || isTypedArray(v) || Buffer.isBuffer(v);
+
+const consoleMethods = {
   log(...args) {
-    this._write(false, this._format(args));
+    if (onLog.hasSubscribers) onLog.publish(args);
+    this[kWriteToConsole](kUseStdout, this[kFormatForStdout](args));
+  },
+  info(...args) {
+    if (onInfo.hasSubscribers) onInfo.publish(args);
+    this[kWriteToConsole](kUseStdout, this[kFormatForStdout](args));
+  },
+  debug(...args) {
+    if (onDebug.hasSubscribers) onDebug.publish(args);
+    this[kWriteToConsole](kUseStdout, this[kFormatForStdout](args));
   },
   warn(...args) {
-    this._write(true, this._format(args));
+    if (onWarn.hasSubscribers) onWarn.publish(args);
+    this[kWriteToConsole](kUseStderr, this[kFormatForStderr](args));
+  },
+  error(...args) {
+    if (onError.hasSubscribers) onError.publish(args);
+    this[kWriteToConsole](kUseStderr, this[kFormatForStderr](args));
   },
   dir(object, options) {
-    this._write(false, inspect(object, { customInspect: false, ...this._inspectOptions, ...options }));
+    this[kWriteToConsole](kUseStdout, inspect(object, { customInspect: false, ...this[kGetInspectOptions](this._stdout), ...options }));
   },
   time(label = "default") {
     label = `${label}`;
@@ -191,19 +344,20 @@ Object.assign(proto, {
   },
   timeEnd(label = "default") {
     label = `${label}`;
-    if (this._timeLog(label, "console.timeEnd()", [])) this._times.delete(label);
+    if (timeLogImpl(this, label, "console.timeEnd()")) this._times.delete(label);
   },
   timeLog(label = "default", ...data) {
-    this._timeLog(`${label}`, "console.timeLog()", data);
+    timeLogImpl(this, `${label}`, "console.timeLog()", data);
   },
+  /* compiled code has no stack frames: the trace is its message */
   trace(...args) {
-    this._write(true, `Trace${args.length ? ": " + this._format(args) : ""}`);
+    this.error(`Trace${args.length ? `: ${this[kFormatForStderr](args)}` : ""}`);
   },
   assert(expression, ...args) {
     if (!expression) {
-      if (typeof args[0] === "string") args[0] = `Assertion failed: ${args[0]}`;
+      if (args.length && typeof args[0] === "string") args[0] = `Assertion failed: ${args[0]}`;
       else args.unshift("Assertion failed");
-      this.warn(...args);
+      Reflect.apply(this.warn, this, args);
     }
   },
   /* only on a terminal: the cursor home, and the screen below it cleared */
@@ -212,53 +366,77 @@ Object.assign(proto, {
   },
   count(label = "default") {
     label = `${label}`;
-    const count = (this._counts.get(label) ?? 0) + 1;
-    this._counts.set(label, count);
+    const counts = this[kCounts];
+    const count = (counts.get(label) ?? 0) + 1;
+    counts.set(label, count);
     this.log(`${label}: ${count}`);
   },
   countReset(label = "default") {
-    label = `${label}`;
-    if (!this._counts.has(label)) {
+    const counts = this[kCounts];
+    if (!counts.has(label)) {
       process.emitWarning(`Count for '${label}' does not exist`);
       return;
     }
-    this._counts.delete(label);
+    counts.delete(`${label}`);
   },
   group(...data) {
-    if (data.length > 0) this.log(...data);
-    this._groupIndent += " ".repeat(this._groupIndentation);
+    if (data.length > 0) Reflect.apply(this.log, this, data);
+    this[kGroupIndentationString] += " ".repeat(this[kGroupIndentationWidth]);
   },
   groupEnd() {
-    this._groupIndent = this._groupIndent.slice(0, this._groupIndent.length - this._groupIndentation);
+    const currentIndentation = this[kGroupIndentationString];
+    this[kGroupIndentationString] = currentIndentation.slice(0, currentIndentation.length - this[kGroupIndentationWidth]);
   },
   table(tabularData, properties) {
     if (properties !== undefined && !Array.isArray(properties)) throw invalidArgType("properties", "an instance of Array", properties);
     if (tabularData === null || typeof tabularData !== "object") return this.log(tabularData);
-    const final = (k, v) => this.log(renderTable(k, v));
+    const final = (k, v) => this.log(cliTable(k, v));
     const _inspect = (v) => {
-      const depth = v !== null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 2 ? -1 : 0;
-      return inspect(v, { depth, maxArrayLength: 3, breakLength: Infinity, ...this._inspectOptions });
+      const depth = v !== null && typeof v === "object" && !isArray(v) && Object.keys(v).length > 2 ? -1 : 0;
+      return inspect(v, { depth, maxArrayLength: 3, breakLength: Infinity, ...this[kGetInspectOptions](this._stdout) });
     };
     const getIndexArray = (length) => Array.from({ length }, (_, i) => _inspect(i));
-    if (tabularData instanceof Map) {
+    const mapIter = isMapIterator(tabularData);
+    let isKeyValue = false;
+    let i = 0;
+    if (mapIter) {
+      [tabularData, isKeyValue] = previewEntries(tabularData, true);
+    }
+    if (isKeyValue || isMap(tabularData)) {
       const keys = [];
       const values = [];
-      for (const [k, v] of tabularData) {
-        keys.push(_inspect(k));
-        values.push(_inspect(v));
+      let length = 0;
+      if (mapIter) {
+        for (; i < tabularData.length / 2; ++i) {
+          keys.push(_inspect(tabularData[i * 2]));
+          values.push(_inspect(tabularData[i * 2 + 1]));
+          length++;
+        }
+      } else {
+        for (const { 0: k, 1: v } of tabularData) {
+          keys.push(_inspect(k));
+          values.push(_inspect(v));
+          length++;
+        }
       }
-      return final(["(iteration index)", "Key", "Values"], [getIndexArray(keys.length), keys, values]);
+      return final([iterKey, keyKey, valuesKey], [getIndexArray(length), keys, values]);
     }
-    if (tabularData instanceof Set || (typeof tabularData.next === "function" && typeof tabularData[Symbol.iterator] === "function")) {
+    const setIter = isSetIterator(tabularData);
+    if (setIter) tabularData = previewEntries(tabularData);
+    if (setIter || mapIter || isSet(tabularData)) {
       const values = [];
-      for (const v of tabularData) values.push(_inspect(v));
-      return final(["(iteration index)", "Values"], [getIndexArray(values.length), values]);
+      let length = 0;
+      for (const v of tabularData) {
+        values.push(_inspect(v));
+        length++;
+      }
+      return final([iterKey, valuesKey], [getIndexArray(length), values]);
     }
-    const map = Object.create(null);
+    const map = { __proto__: null };
     let hasPrimitives = false;
     const valuesKeyArray = [];
     const indexKeyArray = Object.keys(tabularData);
-    for (let i = 0; i < indexKeyArray.length; i++) {
+    for (; i < indexKeyArray.length; i++) {
       const item = tabularData[indexKeyArray[i]];
       const primitive = item === null || (typeof item !== "function" && typeof item !== "object");
       if (properties === undefined && primitive) {
@@ -276,14 +454,21 @@ Object.assign(proto, {
     const keys = Object.keys(map);
     const values = Object.values(map);
     if (hasPrimitives) {
-      keys.push("Values");
+      keys.push(valuesKey);
       values.push(valuesKeyArray);
     }
-    keys.unshift("(index)");
+    keys.unshift(indexKey);
     values.unshift(indexKeyArray);
     return final(keys, values);
   },
-  /* V8 inspector APIs: nothing to report to here */
+};
+
+for (const method of Reflect.ownKeys(consoleMethods)) Console.prototype[method] = consoleMethods[method];
+Console.prototype.dirxml = Console.prototype.log;
+Console.prototype.groupCollapsed = Console.prototype.group;
+
+/* V8 inspector APIs the global console has: nothing to report to here */
+const inspectorMethods = {
   profile() {},
   profileEnd() {},
   timeStamp() {},
@@ -293,30 +478,13 @@ Object.assign(proto, {
   createTask() {
     return { run: (f) => f() };
   },
-});
-proto.debug = proto.log;
-proto.info = proto.log;
-proto.dirxml = proto.log;
-proto.error = proto.warn;
-proto.groupCollapsed = proto.group;
-
-proto._timeLog = function (label, name, data) {
-  const start = this._times.get(label);
-  if (start === undefined) {
-    process.emitWarning(`No such label '${label}' for ${name}`);
-    return false;
-  }
-  const ms = now() - start;
-  this.log("%s: %s", label, formatTime(ms), ...data);
-  return true;
 };
-Object.defineProperty(proto, "_timeLog", { enumerable: false });
 
 /* ---- the module: the global console, with Console, and the V8 extras it lacks ------------------ */
 
 const console = globalThis.console;
-for (const key of ["profile", "profileEnd", "timeStamp", "context", "createTask"]) {
-  if (typeof console[key] !== "function") Object.defineProperty(console, key, { value: proto[key], writable: true, configurable: true });
+for (const key of Object.keys(inspectorMethods)) {
+  if (typeof console[key] !== "function") Object.defineProperty(console, key, { value: inspectorMethods[key], writable: true, configurable: true });
 }
 if (console.Console === undefined) Object.defineProperty(console, "Console", { value: Console, writable: true, configurable: true });
 

package/node/prelude/crypto.js

@@ -3,6 +3,7 @@
 // provided yet throws ERR_VISALJS_UNSUPPORTED when called.
 import { cryptoTimingSafeEqual } from "visaljs:host";
 import { codeError, notSupported } from "./internal/errors.js";
+import { lazyClass } from "./internal/features.js";
 import {
   createECDH, createSign, createVerify, diffieHellman, ECDH, getCurves, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt, Sign,
   sign, Verify, verify,
@@ -17,10 +18,10 @@ import {
   createPrivateKey, createPublicKey, createSecretKey, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, KeyObject,
 } from "./internal/crypto/keys.js";
 import { hkdf, hkdfSync, pbkdf2, pbkdf2Sync, scrypt, scryptSync } from "./internal/crypto/kdf.js";
-import { randomBytes, randomFill, randomFillSync, randomInt, randomUUID } from "./internal/crypto/random.js";
+import { randomBytes, randomFill, randomFillSync, randomInt, randomUUID, randomUUIDv7 } from "./internal/crypto/random.js";
 import { isAnyArrayBuffer, isArrayBufferView } from "./internal/crypto/util.js";
 
-export { createHash, createHmac, getHashes, Hash, hash, Hmac, randomBytes, randomFill, randomFillSync, randomInt, randomUUID };
+export { createHash, createHmac, getHashes, Hash, hash, Hmac, randomBytes, randomFill, randomFillSync, randomInt, randomUUID, randomUUIDv7 };
 export { hkdf, hkdfSync, pbkdf2, pbkdf2Sync, scrypt, scryptSync };
 export { createPrivateKey, createPublicKey, createSecretKey, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, KeyObject };
 export { createECDH, createSign, createVerify, diffieHellman, ECDH, getCurves, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt };
@@ -97,7 +98,8 @@ const unsupported = (name) =>
 export const Certificate = unsupported("Certificate");
 export const Cipher = unsupported("Cipher");
 export const Decipher = unsupported("Decipher");
-export const X509Certificate = unsupported("X509Certificate");
+
+export const X509Certificate = lazyClass("X509Certificate");
 
 export default {
   Certificate, Cipher, Cipheriv, Decipher, Decipheriv, DiffieHellman, DiffieHellmanGroup, ECDH, Hash, Hmac, KeyObject, Sign,
@@ -106,6 +108,6 @@ export default {
   createVerify, diffieHellman, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, generatePrime,
   generatePrimeSync, getCipherInfo, getCiphers, getCurves, getDiffieHellman, getFips, getHashes, getRandomValues, hash, hkdf,
   hkdfSync, pbkdf2, pbkdf2Sync, privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt, randomBytes, randomFill,
-  randomFillSync, randomInt, randomUUID, scrypt, scryptSync, secureHeapUsed, setEngine, setFips, sign, subtle, timingSafeEqual,
+  randomFillSync, randomInt, randomUUID, randomUUIDv7, scrypt, scryptSync, secureHeapUsed, setEngine, setFips, sign, subtle, timingSafeEqual,
   verify, webcrypto,
 };