@wix/himalaya-cli 0.1579.0 → 0.1581.0

package/dist/quickjs-intl.js

@@ -0,0 +1,462 @@
+// ../../core/dev-server/src/quickjs-intl.ts
+var NONFINITE_TAG = "\0himi-nonfinite:";
+var INTL_SHIM = `
+// ############################################################################################
+// NO BACKTICKS AND NO LITERAL NUL ANYWHERE BELOW. This whole block is a TEMPLATE LITERAL in the
+// TypeScript source, so a backtick in a comment terminates it and a NUL byte makes grep treat
+// the entire file as binary and silently match nothing. Both have happened, twice and once
+// respectively, while editing these comments. Write length and this and Intl.X unquoted.
+// ############################################################################################
+(function () {
+  var NF_TAG = ${JSON.stringify(NONFINITE_TAG)};
+
+  // EVERY BUILTIN THIS SHIM USES IS CAPTURED HERE, BEFORE AUTHOR CODE RUNS.
+  //
+  // The shim installs at prelude time and its functions run LATER, inside the bundle's call
+  // stack \u2014 so any global it resolves at call time is a global the bundle can replace first.
+  // Measured: a bundle doing globalThis.Symbol = undefined made every ToPrimitive reduction throw
+  // TypeError, where native Intl kept using the intrinsic well-known symbol and fell back to
+  // valueOf. That is a false FAILURE, and it reached the format path as well as the locale walk
+  // because both share the reduction.
+  //
+  // Same discipline the prelude already applies to its readback channel, and for the same stated
+  // reason: anything reachable after untrusted code runs is reachable BY it. JSON.stringify is
+  // called out there by name as a global that was reassigned in exactly this way.
+  var $Sym = typeof Symbol !== "undefined" && Symbol ? Symbol.toPrimitive : undefined;
+  var $stringify = JSON.stringify, $parse = JSON.parse;
+  var $is = Object.is, $trunc = Math.trunc, $isFinite = isFinite;
+  var $String = String, $Number = Number, $Boolean = Boolean, $TypeError = TypeError;
+  var $now = Date.now;
+  // Reflect.apply, because INVOKING a user function must not read a property off it. The spec's
+  // Call operation goes straight to the function's internal [[Call]]; sp.call(...) consults the
+  // mutable .call slot, which a bundle can poison:
+  //   var f = function () { return 5; }; f.call = function () { throw new Error("poison"); };
+  //   o[Symbol.toPrimitive] = f;  ->  host formats 5, the shim threw "poison"
+  var $apply = Reflect.apply;
+  var D = globalThis.__himiIntlDate, N = globalThis.__himiIntlNumber,
+      C = globalThis.__himiIntlCompare, V = globalThis.__himiIntlValidate,
+      L = globalThis.__himiIntlToLocale;
+  // Captured before any bundle runs, for the same reason every other intrinsic here is: a bundle
+  // that replaces 'Date.prototype.getTime' must not be able to steer what this hands the host.
+  var $Date = Date, $getTime = Date.prototype.getTime;
+  delete globalThis.__himiIntlDate; delete globalThis.__himiIntlNumber;
+  delete globalThis.__himiIntlCompare; delete globalThis.__himiIntlValidate;
+  delete globalThis.__himiIntlToLocale;
+  // Non-finite numbers are TAGGED on the way out. JSON has no spelling for them, so a plain
+  // stringify turns NaN into null, the host reads To$Number(null) === 0, and the one value Intl
+  // rejects becomes a value it accepts.
+  var enc = function (v) {
+    try {
+      if (v === undefined) return "";
+      return $stringify(v, function (k, val) {
+        return typeof val === "number" && !$isFinite(val) ? NF_TAG + $String(val) : val;
+      });
+    } catch (e) { return ""; }
+  };
+
+  // OPTION BAGS ARE READ BY PROPERTY LOOKUP, NOT SERIALIZED. JSON.stringify captures own
+  // ENUMERABLE properties only, while Intl constructors do an ordinary [[Get]] per recognized
+  // key \u2014 so a non-enumerable or prototype-inherited option is meaningful to the host and
+  // invisible to a serializer:
+  //
+  //   var o = {}; Object.defineProperty(o, "style", { value: "currency" });
+  //   new Intl.NumberFormat("en", o)   // host: throws, currency is missing
+  //                                    // $stringify(o) === "{}" -> validated as defaults
+  //
+  // which is a false pass again. So each bag is rebuilt by reading it through the same lookup the
+  // host would use (getters included), and only THAT flat object is serialized.
+  //
+  // READ EXACTLY THE KEYS THE HOST READS, AND NOT ONE MORE. An earlier cut added a for..in
+  // pass so that an option ECMA-402 adds later would still travel rather than be silently
+  // dropped. That was being cleverer than the spec, and it cost a FALSE FAILURE in the other
+  // direction: host Intl never enumerates the bag, it does one [[Get]] per recognized key, so
+  //
+  //   new Intl.NumberFormat("en", { style: "percent", get unrelated() { throw new Error("boom"); } })
+  //     host   "50%"        \u2014 never touches the unrelated getter
+  //     for..in  \u2014 invokes it, and the run dies on someone else's getter
+  //
+  // The residual cost is accepted deliberately: when the host gains an option this list has not
+  // heard of, a bundle using it early would have that option dropped. That needs the host to grow
+  // AND a bundle to adopt it before this list is updated, whereas the getter above breaks a valid
+  // bundle today. Matching the host's read set exactly is the only rule that cannot diverge in
+  // either direction now, and "now" is what a crawl reports on.
+  //
+  // A NON-PRIMITIVE VALUE IS COERCED HERE, NOT DROPPED. Skipping it read as "absent" and the host
+  // does no such thing \u2014 it coerces, and then usually rejects:
+  //
+  //   { style: function () {} }                        host: ToString -> invalid enum -> RangeError
+  //   { style: {} }                                    host: ToString -> invalid enum -> RangeError
+  //   { minimumFractionDigits: { valueOf: () => 3 } }  host: ToNumber -> 3 -> ACCEPTED
+  //
+  // so dropping produced a false pass on the first two, and failing closed would produce a false
+  // FAILURE on the third. Both are forbidden. The coercion is per option class because that is
+  // what the spec does \u2014 ToNumber for the digit counts, ToBoolean for the flags, ToString for
+  // everything else \u2014 and those are language-level operations, so performing them in the guest is
+  // identical to the host performing them. After coercion the value is a primitive and marshals
+  // exactly. A primitive is passed through verbatim and left for the host to coerce, which matters
+  // for useGrouping, where a real boolean and the string "true" are not interchangeable.
+  var NUMK = ["minimumIntegerDigits","minimumFractionDigits","maximumFractionDigits",
+    "minimumSignificantDigits","maximumSignificantDigits","roundingIncrement","fractionalSecondDigits"];
+  var BOOLK = ["hour12","ignorePunctuation","numeric"];
+  var has = function (arr, k) { for (var i = 0; i < arr.length; i++) if (arr[i] === k) return true; return false; };
+  // ToString, which is NOT the $String() function. They differ on exactly one input: $String()
+  // stringifies a Symbol, spec ToString throws. Intl applies ToString to string-valued options
+  // and to both sides of a collation, so $String() reported an ordering where the host threw.
+  var toStr = function (v) {
+    if (typeof v === "symbol") throw new $TypeError("Cannot convert a Symbol value to a string");
+    return $String(v);
+  };
+
+  // CanonicalizeLocaleList, which JSON cannot stand in for. A locale list is walked by INDEX with
+  // a HasProperty check, so a hole is skipped \u2014 while JSON.stringify renders it as null and the
+  // host then rejects the null:
+  //
+  //   new Intl.NumberFormat(Array(1))   host: fine, the hole is skipped
+  //   $stringify(Array(1))          "[null]" -> host TypeError
+  //
+  // which failed a bundle that works. Normalised here to a dense array of strings instead.
+  var encLocales = function (v) {
+    if (v === undefined) return "";
+    if (typeof v === "string") return $stringify([v]);
+    // ToObject: throws for null/undefined and succeeds for everything else. A PRIMITIVE becomes a
+    // wrapper whose length is undefined, which LengthOfArrayLike reads as 0 \u2014 an EMPTY list,
+    // i.e. the default locale. So {} and 5 and even a Symbol are all accepted by the host and
+    // format with the default locale; stringifying them into a locale was a false failure.
+    if (v === null) throw new $TypeError("Cannot convert undefined or null to object");
+    // LengthOfArrayLike, not $Number(): ToLength truncates toward zero and clamps, and ToNumber of
+    // a BigInt throws. length 1.9 means index 0 ONLY \u2014 reading index 1 invoked a getter the host
+    // never touches \u2014 and length 1n is a TypeError rather than 1.
+    var len = v.length;
+    // Reduce it FIRST, the same way every other numeric argument is reduced. LengthOfArrayLike
+    // applies spec ToNumber, which is ToPrimitive then reject-a-BigInt \u2014 so an object whose
+    // primitive is a BigInt is a TypeError, while explicit $Number() on that same object walks
+    // valueOf, gets 1n, and quietly returns 1. This is the round-8 class; the reduction existed
+    // and simply was not applied to length when this walk was written.
+    var lt = typeof len;
+    if (len !== null && (lt === "object" || lt === "function")) len = toPrim(len, "number");
+    if (typeof len === "bigint") throw new $TypeError("Cannot convert a BigInt value to a number");
+    var n = $Number(len);
+    n = n !== n ? 0 : $trunc(n);
+    if (n < 0) n = 0;
+    if (n > 9007199254740991) n = 9007199254740991;
+    var out = [];
+    for (var i = 0; i < n; i++) {
+      if (i in v) {
+        var el = v[i];
+        var et = typeof el;
+        // Each element must be a String or an Object. Anything else is a TypeError on the host,
+        // not the bad-locale RangeError that stringifying it would have produced.
+        if (et !== "string" && !(el !== null && (et === "object" || et === "function"))) {
+          throw new $TypeError("Locale must be a string or an object");
+        }
+        out.push(toStr(el));
+      }
+    }
+    return $stringify(out);
+  };
+
+  // ToPrimitive, so an OBJECT reduces to a primitive before anything classifies it.
+  //
+  // This is what closes the coercion axis instead of adding a third BigInt special case. Explicit
+  // $Number() differs from spec ToNumber in exactly ONE way \u2014 it accepts a BigInt where ToNumber
+  // throws \u2014 so every object whose primitive is a BigInt slipped past a typeof check:
+  //
+  //   { [Symbol.toPrimitive]: () => 1n }                  host TypeError, $Number() gave 1
+  //   { [Symbol.toPrimitive]: () => 9007199254740993n }   host exact, $Number() rounded it
+  //
+  // Reduce first and the primitive paths below \u2014 already exact as of the previous commit \u2014 handle
+  // every input there is. Ordinary order is valueOf-then-toString for a number hint and the
+  // reverse for a string hint, same as the spec.
+  var toPrim = function (v, hint) {
+    if (v === null) return v;
+    var t = typeof v;
+    if (t !== "object" && t !== "function") return v;
+    var sp = v[$Sym];
+    if (sp !== undefined && sp !== null) {
+      var r = $apply(sp, v, [hint]);
+      var rt = typeof r;
+      if (r === null || (rt !== "object" && rt !== "function")) return r;
+      throw new $TypeError("Cannot convert object to primitive value");
+    }
+    var order = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
+    for (var i = 0; i < order.length; i++) {
+      var f = v[order[i]];
+      if (typeof f === "function") {
+        var res = $apply(f, v, []);
+        var rest = typeof res;
+        if (res === null || (rest !== "object" && rest !== "function")) return res;
+      }
+    }
+    throw new $TypeError("Cannot convert object to primitive value");
+  };
+
+  var coerce = function (k, v) {
+    var t = typeof v;
+    // A primitive travels VERBATIM and the host coerces it. That is what keeps useGrouping:false
+    // a boolean rather than the string "false", which the host would reject.
+    if (v === null || t === "string" || t === "number" || t === "boolean") return v;
+    // ToBoolean never calls ToPrimitive \u2014 an object is simply truthy \u2014 so the boolean class must
+    // not be reduced first.
+    if (has(BOOLK, k)) return $Boolean(v);
+    if (t === "bigint") {
+      if (has(NUMK, k)) throw new $TypeError("Cannot convert a BigInt value to a number");
+      return toStr(v);
+    }
+    var p = toPrim(v, has(NUMK, k) ? "number" : "string");
+    if (has(NUMK, k)) {
+      if (typeof p === "bigint") throw new $TypeError("Cannot convert a BigInt value to a number");
+      return $Number(p);
+    }
+    return toStr(p);
+  };
+  var pick = function (o, keys) {
+    var out = {};
+    if (o === undefined) return out;
+    // null IS NOT THE SAME AS OMITTED. The constructors special-case undefined only \u2014 an options
+    // bag goes through ToObject, and ToObject(null) throws \u2014 so treating null as "use defaults"
+    // passed a bundle the host rejects:
+    //   new Intl.NumberFormat("en", null)   host TypeError, this returned {} and validated clean
+    if (o === null) throw new $TypeError("Cannot convert undefined or null to object");
+    for (var i = 0; i < keys.length; i++) {
+      var v = o[keys[i]];
+      if (v !== undefined) out[keys[i]] = coerce(keys[i], v);
+    }
+    return out;
+  };
+  var DTF = ["localeMatcher","calendar","numberingSystem","hour12","hourCycle","timeZone","weekday",
+    "era","year","month","day","dayPeriod","hour","minute","second","fractionalSecondDigits",
+    "timeZoneName","formatMatcher","dateStyle","timeStyle"];
+  var NF = ["localeMatcher","style","currency","currencyDisplay","currencySign","unit","unitDisplay",
+    "numberingSystem","minimumIntegerDigits","minimumFractionDigits","maximumFractionDigits",
+    "minimumSignificantDigits","maximumSignificantDigits","useGrouping","notation","compactDisplay",
+    "signDisplay","roundingMode","roundingIncrement","roundingPriority","trailingZeroDisplay"];
+  var COL = ["localeMatcher","usage","sensitivity","ignorePunctuation","numeric","caseFirst","collation"];
+
+  // NO resolvedOptions(). It would have to invent resolved values \u2014 a locale, a calendar, a
+  // numberingSystem, a timeZone \u2014 and echoing the caller's own option bag back is a confident
+  // wrong answer, not an implementation: a bundle branching on the resolved timeZone would read
+  // undefined here and a real zone on device. Absent, it throws where it is unsupported, which
+  // is the honest failure and the rule the header states.
+  // (No backticks in this string: it is a template literal in the TS source.)
+  //
+  // EVERY CONSTRUCTOR VALIDATES THROUGH THE HOST, because host Intl rejects a bad locale or
+  // option bag AT CONSTRUCTION, not at format time. Deferring meant
+  //   new Intl.NumberFormat("en", { style: "currency" })   // no currency
+  // succeeded here and threw under node:vm, so a bundle that built a bad formatter without
+  // reaching a format call passed the crawl and died on device. Same false-pass class the
+  // swallowed-throw bug was.
+  function DateTimeFormat(locales, options) {
+    if (!(this instanceof DateTimeFormat)) return new DateTimeFormat(locales, options);
+    var l = encLocales(locales), o = enc(pick(options, DTF));
+    V("DateTimeFormat", l, o);
+    // ToNumber on the date argument, which means ToPrimitive first: an object whose primitive is
+    // a BigInt is a TypeError on the host, not a date.
+    this.format = function (d) {
+      var v = d;
+      var t = typeof v;
+      if (v !== null && (t === "object" || t === "function")) v = toPrim(v, "number");
+      if (typeof v === "bigint") throw new $TypeError("Cannot convert a BigInt value to a number");
+      return D(l, o, v === undefined ? $now() : $Number(v));
+    };
+  }
+  function NumberFormat(locales, options) {
+    if (!(this instanceof NumberFormat)) return new NumberFormat(locales, options);
+    var l = encLocales(locales), o = enc(pick(options, NF));
+    V("NumberFormat", l, o);
+    // THE VALUE CROSSES AS A STRING PLUS A KIND, never as a coerced double. Host NumberFormat
+    // takes an Intl mathematical value, which is EXACT for a BigInt and for a numeric string:
+    //   format(9007199254740993n)   -> 9,007,199,254,740,993
+    //   format($Number(that))        -> 9,007,199,254,740,992   <- last digit gone
+    //   format("9007199254740993")  -> 9,007,199,254,740,993
+    // so $Number() here silently reformatted anything past double precision. A number still goes
+    // as a number: $String(Number) round-trips a double exactly.
+    this.format = function (n) {
+      var v = n;
+      var t = typeof v;
+      // ToPrimitive first \u2014 the exactness below is only exact if it sees what the host sees.
+      if (v !== null && (t === "object" || t === "function")) v = toPrim(v, "number");
+      t = typeof v;
+      // $String, not v.toString(): ToString of a BigInt is an internal operation, so it is
+      // unaffected by a replaced BigInt.prototype.toString, which the method call was not.
+      if (t === "bigint") return N(l, o, $String(v), "b");
+      if (t === "string") return N(l, o, v, "s");
+      // NEGATIVE ZERO survives the crossing explicitly. The host prints "-0" \u2014 it keeps the sign
+      // \u2014 while $String(-0) is "0", so the sign was lost on the way out and never came back.
+      // $Number("-0") is -0, so spelling it is enough to restore it.
+      var n2 = $Number(v);
+      return N(l, o, $is(n2, -0) ? "-0" : $String(n2), "n");
+    };
+  }
+  // Collator carries its OPTIONS through. Dropping them made { numeric: true } compare "2" and
+  // "10" lexically \u2014 2 after 10 \u2014 which is a plausible-looking wrong order, the worst kind.
+  function Collator(locales, options) {
+    if (!(this instanceof Collator)) return new Collator(locales, options);
+    var l = encLocales(locales), o = enc(pick(options, COL));
+    V("Collator", l, o);
+    this.compare = function (a, b) { return C(toStr(a), toStr(b), l, o); };
+  }
+
+  globalThis.Intl = { DateTimeFormat: DateTimeFormat, NumberFormat: NumberFormat, Collator: Collator };
+  // QuickJS ships a localeCompare that is a code-unit subtraction, so "a".localeCompare("B") is
+  // 31 where ICU says -1 \u2014 a SIGN FLIP, not a magnitude difference, which silently reverses
+  // every sort a bundle performs. Replaced rather than left alone, and its third argument is
+  // threaded too: localeCompare(that, locales, { numeric: true }) is the idiomatic natural sort.
+  String.prototype.localeCompare = function (that, locales, options) {
+    // STRICT, so this is not boxed. The native method does RequireObjectCoercible on its
+    // receiver and throws for null/undefined; a sloppy replacement has this already rebound to
+    // globalThis by the time it runs, so it stringified the global object and compared happily
+    // where the host threw.
+    "use strict";
+    if (this === null || this === undefined) {
+      throw new $TypeError("String.prototype.localeCompare called on null or undefined");
+    }
+    return C(toStr(this), toStr(that), encLocales(locales), enc(pick(options, COL)));
+  };
+
+  // Date.prototype.toLocale{,Date,Time}String \u2014 SEPARATE built-ins from Intl.DateTimeFormat, and
+  // leaving them native was a real hole. QuickJS-ng implements all three without ICU: it accepts
+  // the options bag and ignores it, so a bundle asking for a short month got a full numeric date
+  // and no error. Measured against node:vm on the sync realm before this existed:
+  //
+  //   toLocaleTimeString("en-US", {hour:"numeric",minute:"2-digit"})   "2:00 AM"    vs "02:00:00 AM"
+  //   toLocaleDateString("en-US", {month:"short"})                     "Jan"        vs "01/01/1970"
+  //   toLocaleString("en-US", {dateStyle:"medium"})                    "Jan 1, 1970" vs "01/01/1970, 02:00:00 AM"
+  //
+  // Options are passed through the SAME 'pick(options, DTF)' whitelist the formatter uses, so one
+  // option vocabulary serves both paths, and the host applies ECMA-402's own defaulting by calling
+  // the very method that was called here.
+  //
+  // STRICT and receiver-checked for the same reason localeCompare above is: the native methods do
+  // their brand check on the receiver, and a sloppy replacement would have 'this' rebound to
+  // globalThis and format the current time instead of throwing.
+  var toLocale = function (kind) {
+    return function (locales, options) {
+      "use strict";
+      if (!(this instanceof $Date)) {
+        throw new $TypeError("Date.prototype.toLocaleString called on a non-Date object");
+      }
+      var t = $getTime.call(this);
+      // An Invalid Date formats as "Invalid Date" on the host too, and NaN cannot cross as a
+      // number \u2014 so it is answered here rather than sent, matching what node:vm returns.
+      if (t !== t) return "Invalid Date";
+      return L(kind, t, encLocales(locales), enc(pick(options, DTF)));
+    };
+  };
+  $Date.prototype.toLocaleString = toLocale("a");
+  $Date.prototype.toLocaleDateString = toLocale("d");
+  $Date.prototype.toLocaleTimeString = toLocale("t");
+})();
+`;
+function installIntl(ctx) {
+  const parse = (s) => {
+    if (!s) return void 0;
+    try {
+      return JSON.parse(
+        s,
+        (_k, val) => typeof val === "string" && val.startsWith(NONFINITE_TAG) ? Number(val.slice(NONFINITE_TAG.length)) : val
+      );
+    } catch {
+      return void 0;
+    }
+  };
+  const hooks = [
+    [
+      "__himiIntlDate",
+      (l, o, t) => {
+        const fmt = new Intl.DateTimeFormat(
+          parse(ctx.getString(l)),
+          parse(ctx.getString(o))
+        );
+        return ctx.newString(fmt.format(new Date(ctx.getNumber(t))));
+      }
+    ],
+    [
+      // `Date.prototype.toLocale*` is NOT `Intl.DateTimeFormat`, and missing that was a real defect
+      // shipped in #1684: QuickJS-ng implements these three natively with no ICU, so it accepts the
+      // options argument and then IGNORES it. Measured against node:vm on the sync realm, before
+      // this hook existed:
+      //
+      //     toLocaleTimeString("en-US", {hour:"numeric",minute:"2-digit"})
+      //       node:vm  "2:00 AM"        realm  "02:00:00 AM"
+      //     toLocaleDateString("en-US", {month:"short"})
+      //       node:vm  "Jan"            realm  "01/01/1970"
+      //
+      // A wrong LABEL, silently — no error, and invisible to a render test, which is the class this
+      // whole bridge exists to close. Bundles reach for `toLocaleTimeString` at least as often as
+      // for `Intl.DateTimeFormat`, so covering only the latter closed half the hole.
+      //
+      // The HOST does the defaulting rather than the guest reimplementing ECMA-402's
+      // ToDateTimeOptions: node is the reference implementation, so calling the very method the
+      // guest called is correct by construction and cannot drift from it.
+      "__himiIntlToLocale",
+      (k, t, l, o) => {
+        const kind = ctx.getString(k);
+        const date = new Date(ctx.getNumber(t));
+        const locales = parse(ctx.getString(l));
+        const options = parse(ctx.getString(o));
+        const out = kind === "d" ? date.toLocaleDateString(locales, options) : kind === "t" ? date.toLocaleTimeString(locales, options) : date.toLocaleString(locales, options);
+        return ctx.newString(out);
+      }
+    ],
+    [
+      "__himiIntlNumber",
+      (l, o, v, k) => {
+        const fmt = new Intl.NumberFormat(
+          parse(ctx.getString(l)),
+          parse(ctx.getString(o))
+        );
+        const raw = ctx.getString(v);
+        const kind = k === void 0 ? "n" : ctx.getString(k);
+        const value = kind === "b" ? BigInt(raw) : kind === "s" ? raw : Number(raw);
+        return ctx.newString(fmt.format(value));
+      }
+    ],
+    [
+      "__himiIntlCompare",
+      (a, b, l, o) => {
+        const collator = new Intl.Collator(
+          parse(ctx.getString(l)),
+          parse(o === void 0 ? "" : ctx.getString(o))
+        );
+        return ctx.newNumber(collator.compare(ctx.getString(a), ctx.getString(b)));
+      }
+    ],
+    [
+      // Construct-and-discard on the host, purely for its throw. Host Intl validates at
+      // CONSTRUCTION; the guest constructors call this so a bad locale or option bag fails at
+      // the same moment it would under node:vm, rather than surviving until a format call the
+      // crawled path may never reach.
+      "__himiIntlValidate",
+      (k, l, o) => {
+        const locales = parse(ctx.getString(l));
+        const options = parse(ctx.getString(o));
+        switch (ctx.getString(k)) {
+          case "DateTimeFormat":
+            new Intl.DateTimeFormat(locales, options);
+            break;
+          case "NumberFormat":
+            new Intl.NumberFormat(locales, options);
+            break;
+          default:
+            new Intl.Collator(locales, options);
+        }
+        return ctx.undefined;
+      }
+    ]
+  ];
+  for (const [name, fn] of hooks) {
+    const handle = ctx.newFunction(name, fn);
+    ctx.setProp(ctx.global, name, handle);
+    handle.dispose();
+  }
+  const res = ctx.evalCode(INTL_SHIM, "himi-intl.js");
+  if (res.error) {
+    const detail = ctx.dump(res.error);
+    res.error.dispose();
+    throw new Error(`Intl shim failed: ${String(detail?.message ?? detail)}`);
+  }
+  res.value.dispose();
+}
+export {
+  installIntl
+};