visaljs 0.0.6 → 0.0.8

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 };