visaljs 0.0.7 → 0.0.9

package/runtime/third_party/ada-idna/convert.mjs

@@ -1,21 +1,97 @@
 // Generates idna_tables.h from Ada's ada_idna.cpp (the single-file IDNA of ada-url/ada, the
 // version Node bundles): the UTS #46 mapping table and the label-validity data, packed for C.
+// Ada 4 keeps its tables in a raw-DEFLATE blob, read here as Ada reads it: a two-level table
+// (64 code points a block) of statuses and UTF-8 mappings, bidi ranges and combining ranges.
 //
 //   node runtime/third_party/ada-idna/convert.mjs <ada>/src/ada_idna.cpp
+import { Buffer } from "node:buffer";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import process from "node:process";
+import { inflateRawSync } from "node:zlib";
 
 const source = readFileSync(process.argv[2], "utf8");
 const version = /\/\/ IDNA\s+([\d.]+)/.exec(source)[1];
 
+/** A `constexpr` number of the source, by name. */
+function constant(name) {
+  const m = new RegExp(`constexpr\\s+(?:size_t|uint32_t|uint16_t)\\s+${name}\\s*=\\s*(0x[0-9a-fA-F]+|\\d+)u?;`).exec(source);
+  if (!m) throw new Error(`no constant ${name}`);
+  return Number(m[1]);
+}
+
 /** The numbers of the C++ array `name` (comments dropped). */
 function array(name) {
-  const m = new RegExp(`\\b${name}\\[[^\\]]*\\](?:\\[[^\\]]*\\])?\\s*=\\s*\\{([\\s\\S]*?)\\};`).exec(source);
+  const m = new RegExp(`\\b${name}\\[[^\\]]*\\]\\s*=\\s*\\{([\\s\\S]*?)\\};`).exec(source);
   if (!m) throw new Error(`no array ${name}`);
   return m[1].replace(/\/\/.*$/gm, "").match(/0x[0-9a-fA-F]+|\d+/g).map(Number);
 }
 
+/* the blob: inflated, little-endian sections at the offsets Ada names */
+const blob = inflateRawSync(Buffer.from(array("compressed")));
+if (blob.length !== constant("uncompressed_size")) throw new Error("the inflated tables aren't Ada's size");
+const section = (name, size) => {
+  const at = constant(`off_${name}`), count = constant(`count_${name}`);
+  const read = { 1: (i) => blob[at + i], 2: (i) => blob.readUInt16LE(at + 2 * i), 4: (i) => blob.readUInt32LE(at + 4 * i),
+    8: (i) => blob.readBigUInt64LE(at + 8 * i) }[size];
+  return Array.from({ length: count }, (_, i) => read(i));
+};
+
+/* ---- the mapping: each code point's status, and its mapping when mapped ---------------------- */
+
+const VALID = 0xffff, DISALLOWED = 0xfffe, IGNORED = 0, BOOL_FLAG = 0x8000;
+const stage1 = section("idna_stage1", 2);
+const stage2 = section("idna_stage2", 2);
+const boolBlocks = section("idna_bool_blocks", 8);
+const utf8 = section("idna_utf8_mappings", 1);
+const LOW_END = constant("IDNA_LOW_RANGE_END");
+const HIGH_IGNORED_START = constant("IDNA_HIGH_IGNORED_START");
+const HIGH_IGNORED_END = constant("IDNA_HIGH_IGNORED_END");
+
+/** Ada's idna_lookup: VALID, DISALLOWED, IGNORED, or an offset into the UTF-8 mappings. */
+function lookup(cp) {
+  if (cp < LOW_END) {
+    const ref = stage1[cp >> 6];
+    if (ref & BOOL_FLAG) {
+      const bit = (ref & ~BOOL_FLAG) * 64 + (cp & 63);
+      return (boolBlocks[bit >> 6] >> BigInt(bit & 63)) & 1n ? VALID : DISALLOWED;
+    }
+    return stage2[ref + (cp & 63)];
+  }
+  return cp >= HIGH_IGNORED_START && cp < HIGH_IGNORED_END ? IGNORED : DISALLOWED;
+}
+
+/** The code points of the NUL-terminated UTF-8 mapping at `at`. */
+function mappingAt(at) {
+  let end = at;
+  while (utf8[end] !== 0) end++;
+  return [...Buffer.from(utf8.slice(at, end)).toString("utf8")].map((c) => c.codePointAt(0));
+}
+
+/* ranges of equal status (and, mapped, equal mapping), as idna.c reads them: status 0 ignored,
+   1 valid, 2 disallowed, 3 mapped */
+const entries = [];
+for (let cp = 0; cp <= 0x10ffff; cp++) {
+  const v = lookup(cp);
+  const status = v === VALID ? 1 : v === DISALLOWED ? 2 : v === IGNORED ? 0 : 3;
+  const mapping = status === 3 ? mappingAt(v) : null;
+  const last = entries[entries.length - 1];
+  if (last && last.status === status && (status !== 3 || last.mapping.join() === mapping.join())) continue;
+  entries.push({ first: cp, status, mapping });
+}
+const mappings = [];
+const keys = [];
+const indices = [];
+for (const { first, status, mapping } of entries) {
+  if (first >= 1 << 21 || (mapping && mapping.length >= 32)) throw new Error("table entry out of range");
+  keys.push((first | (status << 21) | ((mapping ? mapping.length : 0) << 23)) >>> 0);
+  indices.push(mapping ? mappings.length : 0);
+  if (mapping) mappings.push(...mapping);
+}
+if (mappings.length > 0xffff) throw new Error("mappings past a 16-bit index");
+
+/* ---- label validity ----------------------------------------------------------------------- */
+
 /** Sorted code points as [first, last] ranges. */
 function ranges(points) {
   const out = [];
@@ -34,28 +110,14 @@ function rows(values, perLine, hex = true) {
   return lines.join("\n");
 }
 
-/* table[i] = { first code point, descriptor }: code (0 ignored, 1 valid, 2 disallowed, 3 mapped)
- * in the low byte; for a mapping, its index in `mappings` (bits 8-23) and length (bits 24-31).
- * Packed: first | code << 21 | length << 23, and the index apart. */
-const table = array("table");
-const keys = [];
-const indices = [];
-for (let i = 0; i < table.length; i += 2) {
-  const [first, d] = [table[i], table[i + 1]];
-  const code = d & 0xff;
-  const mapped = code > 2;
-  if (first >= 1 << 21 || (mapped && d >>> 24 >= 32)) throw new Error("table entry out of range");
-  keys.push((first | ((mapped ? 3 : code) << 21) | ((mapped ? d >>> 24 : 0) << 23)) >>> 0);
-  indices.push(mapped ? (d >>> 8) & 0xffff : 0);
-}
-const mappings = array("mappings");
-
-/* the bidi classes, in Ada's enum order */
-const DIRECTIONS = ["NONE", "BN", "CS", "ES", "ON", "EN", "L", "R", "NSM", "AL", "AN", "ET", "WS", "RLO", "LRO", "PDF", "RLE", "RLI", "FSI", "PDI", "LRI", "B", "S", "LRE"];
-const dirSource = /dir_table\[\]\s*=\s*\{([\s\S]*?)\};/.exec(source)[1];
-const dirs = [...dirSource.matchAll(/\{(0x[0-9a-f]+),\s*(0x[0-9a-f]+),\s*direction::(\w+)\}/g)].map((m) => [Number(m[1]), Number(m[2]), DIRECTIONS.indexOf(m[3])]);
-
-const sets = Object.fromEntries(["combining", "virama", "R", "L", "D"].map((n) => [n, ranges(array(`static uint32_t ${n}`))]));
+/* the bidi classes: Ada's ranges, in its enum's order (idna.c's enum idna_direction) */
+const dirFirst = section("dir_start", 4);
+const dirLast = section("dir_final", 4);
+const dirClass = section("dir_value", 1);
+const combiningFlat = section("combining_flat", 4);
+const combining = [];
+for (let i = 0; i < combiningFlat.length; i += 2) combining.push([combiningFlat[i], combiningFlat[i + 1]]);
+const sets = { combining, ...Object.fromEntries(["virama", "R", "L", "D"].map((n) => [n, ranges(array(`constexpr static uint32_t ${n}`))])) };
 
 const out = [];
 out.push(`/* Generated by runtime/third_party/ada-idna/convert.mjs from Ada's ada_idna.cpp (IDNA ${version}). Do not edit.`);
@@ -70,10 +132,10 @@ out.push(`static const uint16_t idna_table_index[${indices.length}] = {\n${rows(
 out.push(`static const uint32_t idna_mappings[${mappings.length}] = {\n${rows(mappings, 10)}\n};`);
 out.push("");
 out.push("/* Bidi classes (RFC 5893), as Ada's ranges: first, last, class (enum idna_direction). */");
-out.push(`#define IDNA_DIR_COUNT ${dirs.length}`);
-out.push(`static const uint32_t idna_dir_first[${dirs.length}] = {\n${rows(dirs.map((d) => d[0]), 10)}\n};`);
-out.push(`static const uint32_t idna_dir_last[${dirs.length}] = {\n${rows(dirs.map((d) => d[1]), 10)}\n};`);
-out.push(`static const uint8_t idna_dir_class[${dirs.length}] = {\n${rows(dirs.map((d) => d[2]), 24, false)}\n};`);
+out.push(`#define IDNA_DIR_COUNT ${dirFirst.length}`);
+out.push(`static const uint32_t idna_dir_first[${dirFirst.length}] = {\n${rows(dirFirst, 10)}\n};`);
+out.push(`static const uint32_t idna_dir_last[${dirLast.length}] = {\n${rows(dirLast, 10)}\n};`);
+out.push(`static const uint8_t idna_dir_class[${dirClass.length}] = {\n${rows(dirClass, 24, false)}\n};`);
 out.push("");
 out.push("/* Code point sets of the label-validity rules, as sorted [first, last] ranges. */");
 for (const [name, rs] of Object.entries(sets)) {

package/runtime/third_party/ada-idna/idna.c

@@ -1,5 +1,5 @@
-/* UTS #46 domain to ASCII: a C port of Ada's IDNA (src/ada_idna.cpp of ada-url/ada 2.9.2, the
- * version Node v22 bundles; mapping.cpp, punycode.cpp, validity.cpp and to_ascii.cpp), kept
+/* UTS #46 domain to ASCII: a C port of Ada's IDNA (src/ada_idna.cpp of ada-url/ada 4.0.0, the
+ * version Node v24 bundles; mapping.cpp, punycode.cpp, validity.cpp and to_ascii.cpp), kept
  * step for step, including Ada's quirks, so that hosts come out as Node's do. Copyright Yagiz
  * Nizipli and Daniel Lemire; MIT license (LICENSE-MIT). visaljs's changes: C instead of C++
  * (code point buffers instead of std::u32string), tables packed by convert.mjs, and
@@ -182,6 +182,8 @@ static bool punycode_to_utf32(const char *input, size_t len, U32 *out) {
         written_out++;
         ++i;
     }
+    /* a label that decodes to an xn-- label (encoded twice) is refused: whatwg/url#803 */
+    if (out->n >= 4 && out->v[0] == 'x' && out->v[1] == 'n' && out->v[2] == '-' && out->v[3] == '-') return false;
     return true;
 }
 
@@ -196,7 +198,7 @@ static bool utf32_to_punycode(const uint32_t *input, size_t len, Bytes *out) {
             ++h;
             bytes_push(out, (char)c);
         }
-        if (c > 0x10ffff || (c >= 0xd880 && c < 0xe000)) return false;  /* sic: Ada's bound */
+        if (c > 0x10ffff || (c >= 0xd800 && c < 0xe000)) return false;
     }
     size_t b = h;
     if (b > 0) bytes_push(out, '-');
@@ -289,14 +291,18 @@ static bool is_label_valid(const uint32_t *label, size_t n) {
     unsigned directions = 0;
     for (size_t i = 0; i < n; i++) directions |= 1u << find_direction(label[i]);
     if (!(directions & ((1u << DIR_R) | (1u << DIR_AL) | (1u << DIR_AN)))) return true;
-    if (find_direction(label[0]) == DIR_L) {  /* LTR; Ada checks up to the last non-NSM, exclusive */
-        for (size_t i = 0; i < last_non_nsm; i++) {
+    if (find_direction(label[0]) == DIR_L) {  /* LTR */
+        for (size_t i = 0; i <= last_non_nsm; i++) {
             int d = find_direction(label[i]);
             if (!(d == DIR_L || d == DIR_EN || d == DIR_ES || d == DIR_CS || d == DIR_ET || d == DIR_ON || d == DIR_BN || d == DIR_NSM))
                 return false;
         }
-        return true;
+        int last = find_direction(label[last_non_nsm]);
+        return last == DIR_L || last == DIR_EN;
     }
+    /* RTL: it must begin with R or AL (a leading AN, or anything else, doesn't start one) */
+    int first = find_direction(label[0]);
+    if (first != DIR_R && first != DIR_AL) return false;
     bool has_an = false, has_en = false;
     for (size_t i = 0; i <= last_non_nsm; i++) {
         int d = find_direction(label[i]);
@@ -318,11 +324,16 @@ static bool is_label_valid(const uint32_t *label, size_t n) {
 
 /* ---- To ASCII (to_ascii.cpp) --------------------------------------------------------------- */
 
-/* An xn-- label (its punycode after the prefix): it must decode, be mapped and normalized
- * already, and be valid. */
+/* An xn-- label of a domain that isn't all ASCII (its punycode after the prefix): it must decode
+ * to something not ASCII, be mapped and normalized already, and be valid. */
 static bool check_punycode_label(const char *puny, size_t len) {
     U32 decoded = { 0 }, mapped = { 0 }, normal = { 0 };
     bool ok = punycode_to_utf32(puny, len, &decoded);
+    if (ok) {
+        bool ascii = true;
+        for (size_t i = 0; i < decoded.n && ascii; i++) ascii = decoded.v[i] < 0x80;
+        ok = !ascii;
+    }
     if (ok) {
         map(decoded.v, decoded.n, &mapped);
         ok = u32_equal(decoded.v, decoded.n, mapped.v, mapped.n);
@@ -338,36 +349,24 @@ static bool check_punycode_label(const char *puny, size_t len) {
     return ok;
 }
 
+/* An ASCII domain: lowercased, as the URL standard's domain to ASCII (beStrict false) has it,
+ * whatever its labels (xn-- ones aren't checked) */
 static char *from_ascii_to_ascii(const uint32_t *domain, size_t n, size_t *out_len) {
-    Bytes mapped = { 0 }, out = { 0 };
-    for (size_t i = 0; i < n; i++) bytes_push(&mapped, (char)(domain[i] >= 'A' && domain[i] <= 'Z' ? domain[i] + 32 : domain[i]));
-    size_t label_start = 0;
-    while (label_start != mapped.n) {
-        const char *dot = memchr(mapped.v + label_start, '.', mapped.n - label_start);
-        bool last = dot == NULL;
-        size_t label_size = last ? mapped.n - label_start : (size_t)(dot - (mapped.v + label_start));
-        const char *label = mapped.v + label_start;
-        label_start += last ? label_size : label_size + 1;
-        if (label_size >= 4 && memcmp(label, "xn--", 4) == 0) {
-            bytes_append(&out, label, label_size);
-            if (!check_punycode_label(label + 4, label_size - 4)) goto fail;
-        } else {
-            bytes_append(&out, label, label_size);
-        }
-        if (!last) bytes_push(&out, '.');
+    Bytes out = { 0 };
+    for (size_t i = 0; i < n; i++) bytes_push(&out, (char)(domain[i] >= 'A' && domain[i] <= 'Z' ? domain[i] + 32 : domain[i]));
+    if (out.n == 0) {
+        free(out.v);
+        return NULL;
     }
-    free(mapped.v);
-    if (out.n == 0) goto fail_out;
     *out_len = out.n;
     return out.v;
-fail:
-    free(mapped.v);
-fail_out:
-    free(out.v);
-    return NULL;
 }
 
 char *idna_to_ascii(const uint32_t *domain, size_t n, size_t *out_len) {
+    /* Ada's bound on the input, in UTF-8 bytes */
+    size_t bytes = 0;
+    for (size_t i = 0; i < n; i++) bytes += domain[i] < 0x80 ? 1 : domain[i] < 0x800 ? 2 : domain[i] < 0x10000 ? 3 : 4;
+    if (bytes > 16384) return NULL;
     bool ascii = true;
     for (size_t i = 0; i < n && ascii; i++) ascii = domain[i] < 0x80;
     if (ascii) return from_ascii_to_ascii(domain, n, out_len);