visaljs 0.0.7 → 0.0.9

package/node/prelude/path.js

@@ -1,9 +1,11 @@
-// node:path (ADR 0012, layer 3): Node's lib/path.js (MIT; Node v22), both its win32 and its
+// node:path: Node's lib/path.js (MIT; Node v22), both its win32 and its
 // posix halves, ported: primordials are the methods they stand for, the working directory is the
-// host's, and matchesGlob (minimatch, which visaljs doesn't bundle) is a stub. Results match Node's
+// host's, and matchesGlob is fs.glob's matcher (internal/fs_glob.js). Results match Node's
 // byte for byte; the default export is win32 on Windows, posix elsewhere, as Node's.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { cwd as hostCwd } from "visaljs:host";
-import { invalidArgType, notSupported, validateString } from "./internal/errors.js";
+import { invalidArgType, validateString } from "./internal/errors.js";
+import { feature } from "./internal/features.js";
 
 const CHAR_UPPERCASE_A = 65, CHAR_LOWERCASE_A = 97, CHAR_UPPERCASE_Z = 90, CHAR_LOWERCASE_Z = 122;
 const CHAR_DOT = 46, CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, CHAR_COLON = 58, CHAR_QUESTION_MARK = 63;
@@ -1162,8 +1164,9 @@ const win32 = {
     return ret;
   },
 
-  matchesGlob(_path, _pattern) {
-    throw notSupported('path.matchesGlob');
+  /* internal/fs_glob.js's, linked when the program names it */
+  matchesGlob(path, pattern) {
+    return feature("matchesGlob")(path, pattern);
   },
 
   sep: '\\',
@@ -1644,8 +1647,9 @@ const posix = {
     return ret;
   },
 
-  matchesGlob(_path, _pattern) {
-    throw notSupported('path.matchesGlob');
+  /* internal/fs_glob.js's, linked when the program names it */
+  matchesGlob(path, pattern) {
+    return feature("matchesGlob")(path, pattern);
   },
 
   sep: '/',

package/node/prelude/path_posix.js

@@ -1,4 +1,4 @@
-// node:path/posix (ADR 0012, layer 3): path.posix, on every platform.
+// node:path/posix: path.posix, on every platform.
 import { posix } from "./path.js";
 
 export const {

package/node/prelude/path_win32.js

@@ -1,4 +1,4 @@
-// node:path/win32 (ADR 0012, layer 3): path.win32, on every platform.
+// node:path/win32: path.win32, on every platform.
 import { win32 } from "./path.js";
 
 export const {

package/node/prelude/perf_hooks.js

@@ -0,0 +1,151 @@
+// node:perf_hooks: `performance`'s clock, marks and measures. The clock is
+// process.hrtime's, from when this module loads: timeOrigin is that time on the epoch clock.
+// PerformanceObserver and the histograms are modules of their own (internal/perf_observe.js,
+// internal/perf_histogram.js), linked when the program names them.
+import { codeError, invalidArgType } from "./internal/errors.js";
+import { features, lazyClass, lazyFunction } from "./internal/features.js";
+
+const hrMs = () => {
+  const [s, ns] = process.hrtime();
+  return s * 1e3 + ns / 1e6;
+};
+const origin = hrMs();
+const timeOrigin = Date.now();
+const now = () => hrMs() - origin;
+
+const kConstruct = Symbol("construct");
+
+/* for internal/perf_observe.js's users: the clock, and an entry of another module's (net's 'connect') */
+features.perfNow = now;
+features.perfEntry = (name, entryType, startTime, duration, detail) => new PerformanceEntry(kConstruct, name, entryType, startTime, duration, detail);
+
+export class PerformanceEntry {
+  constructor(key, name, entryType, startTime, duration, detail) {
+    if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+    this.name = name;
+    this.entryType = entryType;
+    this.startTime = startTime;
+    this.duration = duration;
+    this.detail = detail;
+  }
+
+  toJSON() {
+    return { name: this.name, entryType: this.entryType, startTime: this.startTime, duration: this.duration, detail: this.detail };
+  }
+}
+
+export class PerformanceMark extends PerformanceEntry {
+  constructor(name, options) {
+    if (name === undefined) throw codeError(TypeError, "ERR_MISSING_ARGS", 'The "name" argument must be specified');
+    const startTime = options?.startTime ?? now();
+    if (typeof startTime !== "number") throw invalidArgType("options.startTime", "of type number", startTime);
+    super(kConstruct, String(name), "mark", startTime, 0, options?.detail ?? null);
+  }
+}
+
+export class PerformanceMeasure extends PerformanceEntry {
+  constructor(key, name, startTime, duration, detail) {
+    super(key, name, "measure", startTime, duration, detail);
+  }
+}
+
+/* marks and measures, in the order they were made */
+const entries = [];
+
+/** A mark's time: a number as is, else the latest mark of that name. */
+function markTime(mark) {
+  if (typeof mark === "number") return mark;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].entryType === "mark" && entries[i].name === mark) return entries[i].startTime;
+  }
+  throw new globalThis.DOMException('The "' + mark + '" performance mark has not been set', "SyntaxError");
+}
+
+export class Performance {
+  constructor(key) {
+    if (key !== kConstruct) throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+  }
+
+  get timeOrigin() {
+    return timeOrigin;
+  }
+
+  now() {
+    return now();
+  }
+
+  mark(name, options) {
+    const mark = new PerformanceMark(name, options);
+    entries.push(mark);
+    features.perfObserve?.(mark);
+    return mark;
+  }
+
+  /** measure(name, startMark?, endMark?) or measure(name, { start, end, duration, detail }). */
+  measure(name, startOrOptions, endMark) {
+    let start = 0, end, detail = null;
+    if (startOrOptions !== null && typeof startOrOptions === "object") {
+      const { start: s, end: e, duration, detail: d } = startOrOptions;
+      if (s !== undefined) start = markTime(s);
+      end = e !== undefined ? markTime(e) : duration !== undefined ? start + duration : now();
+      detail = d ?? null;
+    } else {
+      if (startOrOptions !== undefined) start = markTime(startOrOptions);
+      end = endMark !== undefined ? markTime(endMark) : now();
+    }
+    const measure = new PerformanceMeasure(kConstruct, String(name), start, end - start, detail);
+    entries.push(measure);
+    features.perfObserve?.(measure);
+    return measure;
+  }
+
+  clearMarks(name) {
+    clear("mark", name);
+  }
+
+  clearMeasures(name) {
+    clear("measure", name);
+  }
+
+  getEntries() {
+    return entries.slice().sort((a, b) => a.startTime - b.startTime);
+  }
+
+  getEntriesByName(name, type) {
+    return this.getEntries().filter((e) => e.name === name && (type === undefined || e.entryType === type));
+  }
+
+  getEntriesByType(type) {
+    return this.getEntries().filter((e) => e.entryType === type);
+  }
+
+  toJSON() {
+    return { timeOrigin };
+  }
+}
+
+function clear(type, name) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].entryType === type && (name === undefined || entries[i].name === name)) entries.splice(i, 1);
+  }
+}
+
+export const performance = new Performance(kConstruct);
+
+export const constants = {
+  NODE_PERFORMANCE_GC_MAJOR: 4, NODE_PERFORMANCE_GC_MINOR: 1, NODE_PERFORMANCE_GC_INCREMENTAL: 8, NODE_PERFORMANCE_GC_WEAKCB: 16,
+  NODE_PERFORMANCE_GC_FLAGS_NO: 0, NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: 2, NODE_PERFORMANCE_GC_FLAGS_FORCED: 4,
+  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: 8, NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: 16,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: 32, NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: 64,
+};
+
+export const PerformanceObserver = lazyClass("PerformanceObserver");
+export const PerformanceObserverEntryList = lazyClass("PerformanceObserverEntryList");
+export const PerformanceResourceTiming = lazyClass("PerformanceResourceTiming");
+export const createHistogram = lazyFunction("createHistogram");
+export const monitorEventLoopDelay = lazyFunction("monitorEventLoopDelay");
+
+export default {
+  Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming,
+  performance, constants, createHistogram, monitorEventLoopDelay,
+};

package/node/prelude/process.js

@@ -1,4 +1,4 @@
-// node:process (ADR 0012, layer 3): the process global, as a module.
+// node:process: the process global, as a module.
 const p = globalThis.process;
 
 export const argv = p.argv;
@@ -9,6 +9,8 @@ export const execPath = p.execPath;
 export const pid = p.pid;
 export const platform = p.platform;
 export const stderr = p.stderr;
+/* made when read, by the module the driver adds when the program names it */
+export const stdin = p.stdin;
 export const stdout = p.stdout;
 export const version = p.version;
 export const versions = p.versions;
@@ -18,6 +20,39 @@ export const exit = (...args) => p.exit(...args);
 export const hrtime = p.hrtime;
 export const nextTick = (...args) => p.nextTick(...args);
 export const kill = (...args) => p.kill(...args);
+/* the members of internal/process_more.js, which the driver adds when the program names them:
+ * called through process, so a program that imports node:process links none of them */
+export const chdir = (...args) => p.chdir(...args);
+export const umask = (...args) => p.umask(...args);
+export const memoryUsage = (...args) => p.memoryUsage(...args);
+export const uptime = (...args) => p.uptime(...args);
+export const cpuUsage = (...args) => p.cpuUsage(...args);
+export const threadCpuUsage = (...args) => p.threadCpuUsage(...args);
+export const resourceUsage = (...args) => p.resourceUsage(...args);
+export const availableMemory = (...args) => p.availableMemory(...args);
+export const constrainedMemory = (...args) => p.constrainedMemory(...args);
+export const setuid = (...args) => p.setuid(...args);
+export const setgid = (...args) => p.setgid(...args);
+export const seteuid = (...args) => p.seteuid(...args);
+export const setegid = (...args) => p.setegid(...args);
+export const getgroups = (...args) => p.getgroups(...args);
+export const setgroups = (...args) => p.setgroups(...args);
+export const initgroups = (...args) => p.initgroups(...args);
+export const abort = (...args) => p.abort(...args);
+export const reallyExit = (...args) => p.reallyExit(...args);
+export const execve = (...args) => p.execve(...args);
+export const getBuiltinModule = (...args) => p.getBuiltinModule(...args);
+export const loadEnvFile = (...args) => p.loadEnvFile(...args);
+export const hasUncaughtExceptionCaptureCallback = (...args) => p.hasUncaughtExceptionCaptureCallback(...args);
+export const setUncaughtExceptionCaptureCallback = (...args) => p.setUncaughtExceptionCaptureCallback(...args);
+export const setSourceMapsEnabled = (...args) => p.setSourceMapsEnabled(...args);
+export const getActiveResourcesInfo = (...args) => p.getActiveResourcesInfo(...args);
+export const openStdin = (...args) => p.openStdin(...args);
+export const ref = (...args) => p.ref(...args);
+export const unref = (...args) => p.unref(...args);
+export const assert = (...args) => p.assert(...args);
+export const binding = (...args) => p.binding(...args);
+export const dlopen = (...args) => p.dlopen(...args);
 /* using it gets the driver to add process's events (node/index.ts) */
 export const emit = (...args) => p.emit(...args);
 

package/node/prelude/punycode.js

@@ -0,0 +1,188 @@
+// node:punycode: Punycode (RFC 3492) and IDNA's toASCII / toUnicode for domain names, as the
+// punycode.js 2.1.0 Node bundles (deprecated in Node, still required by older packages).
+// Ported from punycode.js 2.1.0 (Copyright Mathias Bynens, MIT): node/third_party/punycode/LICENSE.
+
+const maxInt = 2147483647;
+const base = 36;
+const tMin = 1;
+const tMax = 26;
+const skew = 38;
+const damp = 700;
+const initialBias = 72;
+const initialN = 128;
+const delimiter = "-";
+
+const regexPunycode = /^xn--/;
+const regexNonASCII = /[^\0-\x7F]/;
+const regexSeparators = /[\x2E。．｡]/g;  /* RFC 3490 separators */
+
+const errors = {
+  overflow: "Overflow: input needs wider integers to process",
+  "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+  "invalid-input": "Invalid input",
+};
+
+function error(type) {
+  throw new RangeError(errors[type]);
+}
+
+/* a domain name's labels mapped, an email address's local part kept */
+function mapDomain(domain, fn) {
+  const parts = domain.split("@");
+  let result = "";
+  if (parts.length > 1) {
+    result = parts[0] + "@";
+    domain = parts[1];
+  }
+  domain = domain.replace(regexSeparators, "\x2E");
+  const encoded = domain.split(".").map(fn).join(".");
+  return result + encoded;
+}
+
+/** A string's code points: surrogate pairs joined, lone surrogates kept. */
+function ucs2decode(string) {
+  const output = [];
+  let counter = 0;
+  const length = string.length;
+  while (counter < length) {
+    const value = string.charCodeAt(counter++);
+    if (value >= 0xd800 && value <= 0xdbff && counter < length) {
+      const extra = string.charCodeAt(counter++);
+      if ((extra & 0xfc00) === 0xdc00) output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
+      else {
+        output.push(value);
+        counter--;
+      }
+    } else output.push(value);
+  }
+  return output;
+}
+
+/** Code points as a string. */
+const ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
+
+/* a basic code point's digit value, or base for anything else */
+function basicToDigit(codePoint) {
+  if (codePoint >= 0x30 && codePoint < 0x3a) return 26 + (codePoint - 0x30);
+  if (codePoint >= 0x41 && codePoint < 0x5b) return codePoint - 0x41;
+  if (codePoint >= 0x61 && codePoint < 0x7b) return codePoint - 0x61;
+  return base;
+}
+
+/* a digit's code point, lowercase (0..25 a..z, 26..35 0..9) */
+const digitToBasic = (digit) => digit + 22 + 75 * (digit < 26);
+
+/* RFC 3492 3.4 */
+function adapt(delta, numPoints, firstTime) {
+  let k = 0;
+  delta = firstTime ? Math.floor(delta / damp) : delta >> 1;
+  delta += Math.floor(delta / numPoints);
+  for (; delta > ((base - tMin) * tMax) >> 1; k += base) delta = Math.floor(delta / (base - tMin));
+  return Math.floor(k + ((base - tMin + 1) * delta) / (delta + skew));
+}
+
+/** Punycode (ASCII only) to the Unicode string it encodes. */
+export function decode(input) {
+  const output = [];
+  const inputLength = input.length;
+  let i = 0;
+  let n = initialN;
+  let bias = initialBias;
+
+  /* the basic code points: everything before the last delimiter */
+  let basic = input.lastIndexOf(delimiter);
+  if (basic < 0) basic = 0;
+  for (let j = 0; j < basic; ++j) {
+    if (input.charCodeAt(j) >= 0x80) error("not-basic");
+    output.push(input.charCodeAt(j));
+  }
+
+  /* the deltas, each inserting a code point */
+  for (let index = basic > 0 ? basic + 1 : 0; index < inputLength;) {
+    const oldi = i;
+    for (let w = 1, k = base; ; k += base) {
+      if (index >= inputLength) error("invalid-input");
+      const digit = basicToDigit(input.charCodeAt(index++));
+      if (digit >= base) error("invalid-input");
+      if (digit > Math.floor((maxInt - i) / w)) error("overflow");
+      i += digit * w;
+      const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+      if (digit < t) break;
+      const baseMinusT = base - t;
+      if (w > Math.floor(maxInt / baseMinusT)) error("overflow");
+      w *= baseMinusT;
+    }
+    const out = output.length + 1;
+    bias = adapt(i - oldi, out, oldi === 0);
+    if (Math.floor(i / out) > maxInt - n) error("overflow");
+    n += Math.floor(i / out);
+    i %= out;
+    output.splice(i++, 0, n);
+  }
+  return String.fromCodePoint(...output);
+}
+
+/** A Unicode string as Punycode (ASCII only). */
+export function encode(input) {
+  const output = [];
+  input = ucs2decode(input);
+  const inputLength = input.length;
+  let n = initialN;
+  let delta = 0;
+  let bias = initialBias;
+
+  for (const currentValue of input) {
+    if (currentValue < 0x80) output.push(String.fromCharCode(currentValue));
+  }
+  const basicLength = output.length;
+  let handledCPCount = basicLength;
+  if (basicLength) output.push(delimiter);
+
+  while (handledCPCount < inputLength) {
+    /* the next code point to insert: the smallest not yet handled */
+    let m = maxInt;
+    for (const currentValue of input) {
+      if (currentValue >= n && currentValue < m) m = currentValue;
+    }
+    const handledCPCountPlusOne = handledCPCount + 1;
+    if (m - n > Math.floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
+    delta += (m - n) * handledCPCountPlusOne;
+    n = m;
+    for (const currentValue of input) {
+      if (currentValue < n && ++delta > maxInt) error("overflow");
+      if (currentValue === n) {
+        let q = delta;
+        for (let k = base; ; k += base) {
+          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+          if (q < t) break;
+          const qMinusT = q - t;
+          const baseMinusT = base - t;
+          output.push(String.fromCharCode(digitToBasic(t + (qMinusT % baseMinusT))));
+          q = Math.floor(qMinusT / baseMinusT);
+        }
+        output.push(String.fromCharCode(digitToBasic(q)));
+        bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+        delta = 0;
+        ++handledCPCount;
+      }
+    }
+    ++delta;
+    ++n;
+  }
+  return output.join("");
+}
+
+/** A domain name (or email address) with its Punycode labels (xn--…) as Unicode. */
+export function toUnicode(input) {
+  return mapDomain(input, (string) => (regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string));
+}
+
+/** A domain name (or email address) with its non-ASCII labels as Punycode (xn--…). */
+export function toASCII(input) {
+  return mapDomain(input, (string) => (regexNonASCII.test(string) ? "xn--" + encode(string) : string));
+}
+
+export const version = "2.1.0";
+export const ucs2 = { decode: ucs2decode, encode: ucs2encode };
+
+export default { version, ucs2, decode, encode, toASCII, toUnicode };

package/node/prelude/querystring.js

@@ -1,4 +1,4 @@
-// node:querystring (ADR 0012, layer 3): Node's lib/querystring.js (v22.22.2), ported to the host
+// node:querystring: Node's lib/querystring.js (v22.22.2), ported to the host
 // prelude: primordials as plain calls, its requires as imports. Node's notice:
 //
 // Copyright Joyent, Inc. and other Node contributors.

package/node/prelude/readline.js

@@ -0,0 +1,8 @@
+// node:readline (internal/readline.js): Interface, createInterface, the cursor's escapes, and
+// node:readline/promises as promises.
+import promises from "./readline_promises.js";
+import { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor } from "./internal/readline.js";
+
+export { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor, promises };
+
+export default { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor, promises };

package/node/prelude/readline_promises.js

@@ -0,0 +1,88 @@
+// node:readline/promises: node:readline's Interface with question() as a promise, and Readline,
+// cursor moves queued and written by commit().
+import { codeError } from "./internal/errors.js";
+import {
+  Interface as BaseInterface, abortError, clearLineEscape, cursorToEscape, kQuestion, kQuestionCancel, moveCursorEscape,
+} from "./internal/readline.js";
+
+export class Interface extends BaseInterface {
+  /** The next line, or an AbortError when the signal aborts first. */
+  question(query, options = {}) {
+    return new Promise((resolve, reject) => {
+      let cb = resolve;
+      const signal = options?.signal;
+      if (signal) {
+        if (signal === null || typeof signal !== "object" || !("aborted" in signal)) {
+          throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "options.signal" property must be an instance of AbortSignal.');
+        }
+        if (signal.aborted) return reject(abortError(signal));
+        const onAbort = () => {
+          this[kQuestionCancel]();
+          reject(abortError(signal));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        cb = (answer) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(answer);
+        };
+      }
+      this[kQuestion](query, cb);
+    });
+  }
+}
+
+export function createInterface(input, output, completer, terminal) {
+  return new Interface(input, output, completer, terminal);
+}
+
+/** Cursor moves on a stream, queued until commit() (or written at once with autoCommit). */
+export class Readline {
+  #stream;
+  #todo = [];
+  #autoCommit;
+
+  constructor(stream, options = undefined) {
+    if (stream === null || typeof stream !== "object" || typeof stream.write !== "function") {
+      throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "stream" argument must be an instance of Writable.');
+    }
+    this.#stream = stream;
+    this.#autoCommit = Boolean(options?.autoCommit);
+  }
+
+  #add(data) {
+    if (this.#autoCommit) process.nextTick(() => this.#stream.write(data));
+    else this.#todo.push(data);
+    return this;
+  }
+
+  cursorTo(x, y = undefined) {
+    return this.#add(cursorToEscape(x, y));
+  }
+
+  moveCursor(dx, dy) {
+    if (!dx && !dy) return this;
+    return this.#add(moveCursorEscape(dx, dy));
+  }
+
+  clearLine(dir) {
+    return this.#add(clearLineEscape(dir));
+  }
+
+  clearScreenDown() {
+    return this.#add("\x1b[0J");
+  }
+
+  /** Writes what's queued: resolved once written. */
+  commit() {
+    const data = this.#todo.join("");
+    this.#todo = [];
+    return new Promise((resolve) => this.#stream.write(data, resolve));
+  }
+
+  rollback() {
+    this.#todo = [];
+    return this;
+  }
+}
+
+export default { Interface, Readline, createInterface };

package/node/prelude/repl.js

@@ -0,0 +1,38 @@
+// node:repl: a REPL evaluates what's typed, which needs a JavaScript engine a compiled program
+// doesn't have: start() and REPLServer throw ERR_VISALJS_UNSUPPORTED. The constants, writer and
+// Recoverable are Node's.
+import { notSupported } from "./internal/errors.js";
+import { inspect } from "./util.js";
+
+export const REPL_MODE_SLOPPY = Symbol("repl-sloppy");
+export const REPL_MODE_STRICT = Symbol("repl-strict");
+
+/** How the REPL shows a result: util.inspect, with its options. */
+export function writer(obj) {
+  return inspect(obj, writer.options);
+}
+writer.options = { ...inspect.defaultOptions, showProxy: true };
+
+/** An error that more input could resolve. */
+export class Recoverable extends SyntaxError {
+  constructor(err) {
+    super();
+    this.err = err;
+  }
+}
+
+export function start() {
+  throw notSupported("repl.start (evaluating input)");
+}
+
+export class REPLServer {
+  constructor() {
+    throw notSupported("repl.REPLServer (evaluating input)");
+  }
+}
+
+export function isValidSyntax() {
+  throw notSupported("repl.isValidSyntax (parsing source text)");
+}
+
+export default { REPL_MODE_SLOPPY, REPL_MODE_STRICT, REPLServer, Recoverable, isValidSyntax, start, writer };

package/node/prelude/sea.js

@@ -0,0 +1,23 @@
+// node:sea: a visaljs binary isn't one of Node's single executable applications: isSea() is false,
+// and the asset calls throw ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION, as Node's do outside one.
+import { codeError } from "./internal/errors.js";
+
+const notInSea = () =>
+  codeError(Error, "ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION", "Operation cannot be invoked when not in a single-executable application");
+
+export const isSea = () => false;
+
+export function getAsset() {
+  throw notInSea();
+}
+export function getAssetAsBlob() {
+  throw notInSea();
+}
+export function getRawAsset() {
+  throw notInSea();
+}
+export function getAssetKeys() {
+  throw notInSea();
+}
+
+export default { isSea, getAsset, getAssetAsBlob, getRawAsset, getAssetKeys };