unicode-input-toolconverter 0.2.0 → 0.2.3

package/vendor/fflate/esm/browser.js

@@ -192,7 +192,7 @@ var ec = [
     'invalid distance',
     'stream finished',
     'no stream handler',
-    ,
+    , // determined by compression function
     'no callback',
     'invalid UTF-8 data',
     'extra field too long',
@@ -909,12 +909,12 @@ var cbify = function (dat, opts, fns, init, id, cb) {
 var astrm = function (strm) {
     strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };
     return function (ev) {
-        if (ev.data.length) {
+        if (ev.data[0]) {
             strm.push(ev.data[0], ev.data[1]);
             postMessage([ev.data[0].length]);
         }
         else
-            strm.flush();
+            strm.flush(ev.data[1]);
     };
 };
 // async stream attach
@@ -944,17 +944,19 @@ var astrmify = function (fns, strm, opts, init, id, flush, ext) {
         if (t)
             strm.ondata(err(4, 0, 1), null, !!f);
         strm.queuedSize += d.length;
-        w.postMessage([d, t = f], [d.buffer]);
+        // can fail for cross-realm Uint8Array, but ok - only a small performance penalty
+        w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []);
     };
     strm.terminate = function () { w.terminate(); };
     if (flush) {
-        strm.flush = function () { w.postMessage([]); };
+        strm.flush = function (sync) { w.postMessage([0, sync]); };
     }
 };
 // read 2 bytes
 var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
 // read 4 bytes
 var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
+// read 8 bytes
 var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
 // write bytes
 var wbytes = function (d, b, v) {
@@ -1075,18 +1077,37 @@ var Deflate = /*#__PURE__*/ (function () {
             this.p(this.b, final || false);
             this.s.w = this.s.i, this.s.i -= 2;
         }
+        if (final) {
+            // cleanup unneeded buffers/state to reduce memory usage
+            this.s = this.o = {};
+            this.b = et;
+        }
     };
     /**
      * Flushes buffered uncompressed data. Useful to immediately retrieve the
      * deflated output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible. A separate DEFLATE stream may be concatenated
+     *             with the current output after a sync flush.
      */
-    Deflate.prototype.flush = function () {
+    Deflate.prototype.flush = function (sync) {
         if (!this.ondata)
             err(5);
         if (this.s.l)
             err(4);
         this.p(this.b, false);
         this.s.w = this.s.i, this.s.i -= 2;
+        // could technically skip writing the type-0 block for (this.s.r & 7) == 0,
+        // but the deterministic trailer (00 00 FF FF) is useful in some situations
+        if (sync) {
+            var c = new u8(6);
+            c[0] = this.s.r >> 3;
+            // write empty, non-final type-0 block
+            var ep = wfblk(c, this.s.r, et);
+            this.s.r = 0;
+            this.ondata(c.subarray(0, ep >> 3), false);
+        }
     };
     return Deflate;
 }());
@@ -1197,12 +1218,6 @@ export function inflate(data, opts, cb) {
         bInflt
     ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);
 }
-/**
- * Expands DEFLATE data with no wrapper
- * @param data The data to decompress
- * @param opts The decompression options
- * @returns The decompressed version of the data
- */
 export function inflateSync(data, opts) {
     return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
 }
@@ -1238,9 +1253,12 @@ var Gzip = /*#__PURE__*/ (function () {
     /**
      * Flushes buffered uncompressed data. Useful to immediately retrieve the
      * GZIPped output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
      */
-    Gzip.prototype.flush = function () {
-        Deflate.prototype.flush.call(this);
+    Gzip.prototype.flush = function (sync) {
+        Deflate.prototype.flush.call(this, sync);
     };
     return Gzip;
 }());
@@ -1318,14 +1336,17 @@ var Gunzip = /*#__PURE__*/ (function () {
         }
         // necessary to prevent TS from using the closure value
         // This allows for workerization to function correctly
-        Inflate.prototype.c.call(this, final);
+        Inflate.prototype.c.call(this, 0);
         // process concatenated GZIP
-        if (this.s.f && !this.s.l && !final) {
+        if (this.s.f && !this.s.l) {
             this.v = shft(this.s.p) + 9;
             this.s = { i: 0 };
             this.o = new u8(0);
             this.push(new u8(0), final);
         }
+        else if (final) {
+            Inflate.prototype.c.call(this, final);
+        }
     };
     return Gunzip;
 }());
@@ -1360,12 +1381,6 @@ export function gunzip(data, opts, cb) {
         function () { return [gunzipSync]; }
     ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb);
 }
-/**
- * Expands GZIP data
- * @param data The data to decompress
- * @param opts The decompression options
- * @returns The decompressed version of the data
- */
 export function gunzipSync(data, opts) {
     var st = gzs(data);
     if (st + 8 > data.length)
@@ -1401,9 +1416,12 @@ var Zlib = /*#__PURE__*/ (function () {
     /**
      * Flushes buffered uncompressed data. Useful to immediately retrieve the
      * zlibbed output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
      */
-    Zlib.prototype.flush = function () {
-        Deflate.prototype.flush.call(this);
+    Zlib.prototype.flush = function (sync) {
+        Deflate.prototype.flush.call(this, sync);
     };
     return Zlib;
 }());
@@ -1510,12 +1528,6 @@ export function unzlib(data, opts, cb) {
         function () { return [unzlibSync]; }
     ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb);
 }
-/**
- * Expands Zlib data
- * @param data The data to decompress
- * @param opts The decompression options
- * @returns The decompressed version of the data
- */
 export function unzlibSync(data, opts) {
     return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
 }
@@ -1636,7 +1648,7 @@ var fltn = function (d, p, t, o) {
         var val = d[k], n = p + k, op = o;
         if (Array.isArray(val))
             op = mrg(o, val[1]), val = val[0];
-        if (val instanceof u8)
+        if (ArrayBuffer.isView(val))
             t[n] = [val, op];
         else {
             t[n += '/'] = [new u8(0), op];
@@ -1821,15 +1833,30 @@ var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };
 var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
 // read zip header
 var zh = function (d, b, z) {
-    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
-    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
-    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+    var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+    var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2];
+    return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
 };
-// read zip64 extra field
-var z64e = function (d, b) {
-    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
-        ;
-    return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+// read zip64 header sizes
+var z64hs = function (d, b, l, z, sc, su, off) {
+    var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+    var nf = nsc + nsu + noff;
+    if (z && nf) {
+        for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
+            if (b2(d, b) == 1) {
+                return [
+                    nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+                    nsu ? b8(d, b + 4) : su,
+                    noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+                    1
+                ];
+            }
+        }
+        // z == 2 for unknown whether or not zip64
+        if (z < 2)
+            err(13);
+    }
+    return [sc, su, off, 0];
 };
 // extra field length
 var exfl = function (ex) {
@@ -1931,6 +1958,8 @@ var ZipPassThrough = /*#__PURE__*/ (function () {
         this.size += chunk.length;
         if (final)
             this.crc = this.c.d();
+        // we shouldn't really do this cast, but properly handling ArrayBufferLike
+        // makes the API unergonomic with Buffer
         this.process(chunk, final || false);
     };
     return ZipPassThrough;
@@ -2310,8 +2339,9 @@ export function zipSync(data, opts) {
 var UnzipPassThrough = /*#__PURE__*/ (function () {
     function UnzipPassThrough() {
     }
-    UnzipPassThrough.prototype.push = function (data, final) {
-        this.ondata(null, data, final);
+    UnzipPassThrough.prototype.push = function (chunk, final) {
+        // same as ZipPassThrough: cast to retain Buffer ergonomics
+        this.ondata(null, chunk, final);
     };
     UnzipPassThrough.compression = 0;
     return UnzipPassThrough;
@@ -2331,9 +2361,9 @@ var UnzipInflate = /*#__PURE__*/ (function () {
             _this.ondata(null, dat, final);
         });
     }
-    UnzipInflate.prototype.push = function (data, final) {
+    UnzipInflate.prototype.push = function (chunk, final) {
         try {
-            this.i.push(data, final);
+            this.i.push(chunk, final);
         }
         catch (e) {
             this.ondata(e, null, final);
@@ -2364,10 +2394,10 @@ var AsyncUnzipInflate = /*#__PURE__*/ (function () {
             this.terminate = this.i.terminate;
         }
     }
-    AsyncUnzipInflate.prototype.push = function (data, final) {
+    AsyncUnzipInflate.prototype.push = function (chunk, final) {
         if (this.i.terminate)
-            data = slc(data, 0);
-        this.i.push(data, final);
+            chunk = slc(chunk, 0);
+        this.i.push(chunk, final);
     };
     AsyncUnzipInflate.compression = 8;
     return AsyncUnzipInflate;
@@ -2424,7 +2454,6 @@ var Unzip = /*#__PURE__*/ (function () {
             }
             var l = buf.length, oc = this.c, add = oc && this.d;
             var _loop_2 = function () {
-                var _a;
                 var sig = b4(buf, i);
                 if (sig == 0x4034B50) {
                     f = 1, is = i;
@@ -2435,13 +2464,11 @@ var Unzip = /*#__PURE__*/ (function () {
                         var chks_3 = [];
                         this_1.k.unshift(chks_3);
                         f = 2;
-                        var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);
+                        var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22);
                         var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
-                        if (sc_1 == 4294967295) {
-                            _a = dd ? [-2] : z64e(buf, i), sc_1 = _a[0], su_1 = _a[1];
-                        }
-                        else if (dd)
-                            sc_1 = -1;
+                        var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3];
+                        if (dd)
+                            sc_1 = -1 - z64;
                         i += es;
                         this_1.c = sc_1;
                         var d_1;
@@ -2554,7 +2581,7 @@ export function unzip(data, opts, cb) {
     if (lft) {
         var c = lft;
         var o = b4(data, e + 16);
-        var z = o == 4294967295 || c == 65535;
+        var z = b4(data, e - 20) == 0x7064B50;
         if (z) {
             var ze = b4(data, e - 12);
             z = b4(data, ze) == 0x6064B50;
@@ -2634,7 +2661,7 @@ export function unzipSync(data, opts) {
     if (!c)
         return {};
     var o = b4(data, e + 16);
-    var z = o == 4294967295 || c == 65535;
+    var z = b4(data, e - 20) == 0x7064B50;
     if (z) {
         var ze = b4(data, e - 12);
         z = b4(data, ze) == 0x6064B50;

package/vendor/intl-dom/dist/Formatter.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Base class for formatting.
+ */
+export declare class Formatter {
+}
+/**
+ * Formatter for local variables.
+ */
+export declare class LocalFormatter extends Formatter {
+    locals: import("./getMessageForKeyByStyle.js").LocaleBody;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    static isMatchingKey(key: string): boolean;
+    /**
+     * @param {import('./getMessageForKeyByStyle.js').LocalObject} locals
+     */
+    constructor(locals: import('./getMessageForKeyByStyle.js').LocalObject);
+    /**
+     * @param {string} key
+     * @returns {string|Element}
+     */
+    getSubstitution(key: string): string | Element;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    isMatch(key: string): boolean;
+}
+/**
+ * Formatter for regular variables.
+ */
+export declare class RegularFormatter extends Formatter {
+    substitutions: import("./defaultLocaleResolver.js").SubstitutionObject;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    static isMatchingKey(key: string): boolean;
+    /**
+     * @param {import('./defaultLocaleResolver.js').SubstitutionObject
+     * } substitutions
+     */
+    constructor(substitutions: import('./defaultLocaleResolver.js').SubstitutionObject);
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    isMatch(key: string): boolean;
+}
+export type SwitchMatch = [
+    objKey?: string,
+    body?: import('./getMessageForKeyByStyle.js').LocaleBody,
+    keySegment?: string
+];
+export type Integer = number;
+/**
+ * Formatter for switch variables.
+ */
+export declare class SwitchFormatter extends Formatter {
+    switches: import("./defaultLocaleResolver.js").Switches;
+    substitutions: import("./defaultLocaleResolver.js").SubstitutionObject;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    static isMatchingKey(key: string): boolean;
+    /**
+     * @param {string} key
+     * @returns {string}
+     */
+    static getKey(key: string): string;
+    /**
+     * @param {import('./defaultLocaleResolver.js').Switches} switches
+     * @param {object} cfg
+     * @param {import('./defaultLocaleResolver.js').
+     *   SubstitutionObject} cfg.substitutions
+     */
+    constructor(switches: import('./defaultLocaleResolver.js').Switches, { substitutions }: {
+        substitutions: import('./defaultLocaleResolver.js').SubstitutionObject;
+    });
+    /**
+     * @param {string} key
+     * @param {object} cfg
+     * @param {string} cfg.locale
+     * @param {(string|undefined)[]} cfg.usedKeys
+     * @param {string} cfg.arg
+     * @param {import('./getDOMForLocaleString.js').
+     *   MissingSuppliedFormattersCallback} cfg.missingSuppliedFormatters
+     * @returns {string}
+     */
+    getSubstitution(key: string, { locale, usedKeys, arg, missingSuppliedFormatters }: {
+        locale: string;
+        usedKeys: (string | undefined)[];
+        arg: string;
+        missingSuppliedFormatters: import('./getDOMForLocaleString.js').MissingSuppliedFormattersCallback;
+    }): string;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    isMatch(key: string): boolean;
+    /**
+     * @typedef {[
+     *   objKey?: string,
+     *   body?: import('./getMessageForKeyByStyle.js').LocaleBody,
+     *   keySegment?: string
+     * ]} SwitchMatch
+     */
+    /**
+     * @typedef {number} Integer
+     */
+    /**
+     * @param {string} ky
+     * @returns {SwitchMatch}
+     */
+    getMatch(ky: string): SwitchMatch;
+}
+//# sourceMappingURL=Formatter.d.ts.map

package/vendor/intl-dom/dist/Formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Formatter.d.ts","sourceRoot":"","sources":["../src/Formatter.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,qBAAa,SAAS;CACrB;AAuBD;;GAEG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAcpC,MAAM;IAbb;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAE,GAAG,EAHd,MAGc,GAFZ,OAAO,CAInB;IAED;;OAEG;IACH,YAAa,MAAM,EAFR,OAAO,8BAA8B,EAAE,WAE/B,EAGlB;IACD;;;OAGG;IACH,eAAe,CAAE,GAAG,EAHT,MAGS,GAFP,MAAM,GAAC,OAAO,CAM1B;IACD;;;OAGG;IACH,OAAO,CAAE,GAAG,EAHD,MAGC,GAFC,OAAO,CA6BnB;CACF;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAetC,aAAa;IAdpB;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAE,GAAG,EAHd,MAGc,GAFZ,OAAO,CAInB;IAED;;;OAGG;IACH,YAAa,aAAa,EAHf,OAAO,4BAA4B,EAAE,kBAGtB,EAGzB;IACD;;;OAGG;IACH,OAAO,CAAE,GAAG,EAHD,MAGC,GAFC,OAAO,CAMnB;CACF;AAyNI,YAIG,WAAW,GAJJ;IACR,MAAM,CAAC,EAAE,MAAM;IACf,IAAI,CAAC,EAAE,OAAO,8BAA8B,EAAE,UAAU;IACxD,UAAU,CAAC,EAAE,MAAM;CACpB,CAAa;AAId,YAAkB,OAAO,GAAf,MAAM,CAAS;AA/N9B;;GAEG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAyBrC,QAAQ;IACR,aAAa;IAzBpB;;;OAGG;IACH,MAAM,CAAC,aAAa,CAAE,GAAG,EAHd,MAGc,GAFZ,OAAO,CAInB;IACD;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAE,GAAG,EAHP,MAGO,GAFL,MAAM,CAKlB;IAED;;;;;OAKG;IACH,YAAa,QAAQ,EALV,OAAO,4BAA4B,EAAE,QAK3B,EAAE,EAAC,aAAa,EAAC,EAHnC;QAC0B,aAAa,EAD/B,OAAO,4BAA4B,EACzC,kBAAkB,CACtB;KACqC,EAIrC;IAED;;;;;;;;;OASG;IACH,eAAe,CAAE,GAAG,EATT,MASS,EAAE,EAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,yBAAyB,EAAC,EAPrE;QAAoB,MAAM,EAAlB,MAAM,CACd;QAAkC,QAAQ,EAAlC,CAAC,MAAM,GAAC,SAAS,CAAC,EAAE,CAC5B;QAAoB,GAAG,EAAf,MAAM,CACd;QACyC,yBAAyB,EAD1D,OAAO,4BAA4B,EACzC,iCAAiC,CACnC;KAEqE,GAF3D,MAAM,CA+JlB;IAED;;;OAGG;IACH,OAAO,CAAE,GAAG,EAHD,MAGC,GAFC,OAAO,CASnB;IAED;;;;;;OAMG;IAEH;;OAEG;IAEH;;;OAGG;IACH,QAAQ,CAAE,EAAE,EAHD,MAGC,GAFC,WAAW,CA6CvB;CACF"}

package/vendor/intl-dom/dist/collation.d.ts

@@ -0,0 +1,42 @@
+export { setDocument, getDocument } from './shared.js';
+/**
+ *
+ * @param {string} locale
+ * @param {string[]} arrayOfItems
+ * @param {Intl.CollatorOptions|undefined} options
+ * @returns {string[]}
+ */
+export declare const sort: (locale: string, arrayOfItems: string[], options: Intl.CollatorOptions | undefined) => string[];
+/**
+ *
+ * @param {string} locale
+ * @param {string[]} arrayOfItems
+ * @param {Intl.ListFormatOptions|undefined} [options]
+ * @returns {string}
+ */
+export declare const list: (locale: string, arrayOfItems: string[], options?: Intl.ListFormatOptions | undefined) => string;
+/**
+ *
+ * @param {string} locale
+ * @param {string[]} arrayOfItems
+ * @param {Intl.ListFormatOptions|undefined} [listOptions]
+ * @param {Intl.CollatorOptions|undefined} [collationOptions]
+ * @returns {string}
+ */
+export declare const sortListSimple: (locale: string, arrayOfItems: string[], listOptions?: Intl.ListFormatOptions | undefined, collationOptions?: Intl.CollatorOptions | undefined) => string;
+export type Integer = number;
+/**
+ * @typedef {number} Integer
+ */
+/**
+ *
+ * @param {string} locale
+ * @param {string[]} arrayOfItems
+ * @param {import('./index.js').SortListMapper|
+ *   Intl.ListFormatOptions|undefined} map
+ * @param {Intl.ListFormatOptions|undefined} [listOptions]
+ * @param {Intl.CollatorOptions|undefined} [collationOptions]
+ * @returns {DocumentFragment|string}
+ */
+export declare const sortList: (locale: string, arrayOfItems: string[], map: import('./index.js').SortListMapper | Intl.ListFormatOptions | undefined, listOptions?: Intl.ListFormatOptions | undefined, collationOptions?: Intl.CollatorOptions | undefined) => DocumentFragment | string;
+//# sourceMappingURL=collation.d.ts.map

package/vendor/intl-dom/dist/collation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collation.d.ts","sourceRoot":"","sources":["../src/collation.js"],"names":[],"mappings":"AAGA,OAAO,EAAC,WAAW,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAuBrD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,WALN,MAAM,gBACN,MAAM,EAAE,WACR,IAAI,CAAC,eAAe,GAAC,SAAS,KAC5B,MAAM,EAQlB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,WALN,MAAM,gBACN,MAAM,EAAE,YACR,IAAI,CAAC,iBAAiB,GAAC,SAAS,KAC9B,MAMZ,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,WANhB,MAAM,gBACN,MAAM,EAAE,gBACR,IAAI,CAAC,iBAAiB,GAAC,SAAS,qBAChC,IAAI,CAAC,eAAe,GAAC,SAAS,KAC5B,MAOZ,CAAC;AAGC,YAAkB,OAAO,GAAf,MAAM,CAAS;AAD5B;;GAEG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,WARV,MAAM,gBACN,MAAM,EAAE,OACR,OAAO,YAAY,EAAE,cAAc,GACzC,IAAI,CAAC,iBAAiB,GAAC,SAAS,gBAC1B,IAAI,CAAC,iBAAiB,GAAC,SAAS,qBAChC,IAAI,CAAC,eAAe,GAAC,SAAS,KAC5B,gBAAgB,GAAC,MA6C7B,CAAC"}

package/vendor/intl-dom/dist/defaultAllSubstitutions.d.ts

@@ -0,0 +1,52 @@
+export type Integer = number;
+/**
+ * @typedef {number} Integer
+ */
+/**
+ * @param {{
+ *   object: import('./defaultLocaleResolver.js').DateRangeValueArray|
+ *     import('./defaultLocaleResolver.js').ListValueArray|
+ *     import('./defaultLocaleResolver.js').RelativeValueArray|
+ *     import('./defaultLocaleResolver.js').ValueArray
+ * }} cfg
+ * @returns {{
+ *   value: number|string|string[]|Date,
+ *   options?: Intl.NumberFormatOptions|Intl.PluralRulesOptions|
+ *     string|Date|number,
+ *   extraOpts?: object,
+ *   callback?: (item: string, i: Integer) => Element
+ * }}
+ */
+export declare const getFormatterInfo: ({ object }: {
+    object: import('./defaultLocaleResolver.js').DateRangeValueArray | import('./defaultLocaleResolver.js').ListValueArray | import('./defaultLocaleResolver.js').RelativeValueArray | import('./defaultLocaleResolver.js').ValueArray;
+}) => {
+    value: number | string | string[] | Date;
+    options?: Intl.NumberFormatOptions | Intl.PluralRulesOptions | string | Date | number;
+    extraOpts?: object;
+    callback?: (item: string, i: Integer) => Element;
+};
+export type AllSubstitutionCallback = (info: {
+    value: import('./defaultLocaleResolver.js').SubstitutionObjectValue;
+    arg?: string;
+    key?: string;
+    locale?: string;
+}) => string | Node;
+/**
+ * Callback to give replacement text based on a substitution value.
+ *
+ * `value` - contains the value returned by the individual substitution.
+ * `arg` - See `cfg.arg` of {@link SubstitutionCallback}.
+ * `key` - The substitution key Not currently in use
+ * `locale` - The locale.
+ * @typedef {(info: {
+ *   value: import('./defaultLocaleResolver.js').SubstitutionObjectValue
+ *   arg?: string,
+ *   key?: string,
+ *   locale?: string
+ * }) => string|Node} AllSubstitutionCallback
+ */
+/**
+ * @type {AllSubstitutionCallback}
+ */
+export declare const defaultAllSubstitutions: AllSubstitutionCallback;
+//# sourceMappingURL=defaultAllSubstitutions.d.ts.map

package/vendor/intl-dom/dist/defaultAllSubstitutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultAllSubstitutions.d.ts","sourceRoot":"","sources":["../src/defaultAllSubstitutions.js"],"names":[],"mappings":"AAIG,YAAkB,OAAO,GAAf,MAAM,CAAS;AAD5B;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,eAdlB;IACN,MAAM,EAAE,OAAO,4BAA4B,EAAE,mBAAmB,GACpE,OAAa,4BAA4B,EAAE,cAAc,GACzD,OAAa,4BAA4B,EAAE,kBAAkB,GAC7D,OAAa,4BAA4B,EAAE,UAAU,CAAA;CAClD,KACS;IACR,KAAK,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GAAC,IAAI,CAAC;IACnC,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,GAAC,IAAI,CAAC,kBAAkB,GAC9D,MAAY,GAAC,IAAI,GAAC,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;CAoBpD,CAAC;AASC,YAKmB,uBAAuB,GALhC,CAAC,IAAI,EAAE;IACf,KAAK,EAAE,OAAO,4BAA4B,EAAE,uBAAuB,CAAA;IACnE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,KAAK,MAAM,GAAC,IAAI,CAAyB;AAZ7C;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAF1B,uBAoNT,CAAC"}

package/vendor/intl-dom/dist/defaultInsertNodes.d.ts

@@ -0,0 +1,96 @@
+export type Integer = number;
+export type Replace = (cfg: {
+    str: string;
+    substs?: import('./defaultLocaleResolver.js').SubstitutionObject;
+    formatter?: import('./Formatter.js').RegularFormatter | import('./Formatter.js').LocalFormatter | import('./Formatter.js').SwitchFormatter;
+}) => string;
+export type ProcessSubstitutions = (cfg: {
+    str: string;
+    substs?: import('./defaultLocaleResolver.js').SubstitutionObject;
+    formatter?: import('./Formatter.js').RegularFormatter | import('./Formatter.js').LocalFormatter | import('./Formatter.js').SwitchFormatter;
+}) => (string | Node)[];
+export type InsertNodesCallback = (cfg: {
+    string: string;
+    dom?: boolean;
+    usedKeys: string[];
+    substitutions: import('./defaultLocaleResolver.js').SubstitutionObject;
+    allSubstitutions?: (import('./defaultAllSubstitutions.js').AllSubstitutionCallback | import('./defaultAllSubstitutions.js').AllSubstitutionCallback[]) | null;
+    locale: string | undefined;
+    locals?: import('./getMessageForKeyByStyle.js').LocalObject | undefined;
+    switches: import('./defaultLocaleResolver.js').Switches | undefined;
+    maximumLocalNestingDepth?: Integer;
+    missingSuppliedFormatters: import('./getDOMForLocaleString.js').MissingSuppliedFormattersCallback;
+    checkExtraSuppliedFormatters: import('./getDOMForLocaleString.js').CheckExtraSuppliedFormattersCallback;
+}) => string | (Node | string)[];
+/**
+ * @typedef {number} Integer
+ */
+/**
+ * @callback Replace
+ * @param {{
+ *   str: string,
+ *   substs?: import('./defaultLocaleResolver.js').SubstitutionObject,
+ *   formatter?: import('./Formatter.js').RegularFormatter|
+ *     import('./Formatter.js').LocalFormatter|
+ *     import('./Formatter.js').SwitchFormatter
+ * }} cfg
+ * @returns {string}
+ */
+/**
+ * @callback ProcessSubstitutions
+ * @param {{
+ *   str: string,
+ *   substs?: import('./defaultLocaleResolver.js').SubstitutionObject,
+ *   formatter?: import('./Formatter.js').RegularFormatter|
+ *     import('./Formatter.js').LocalFormatter|
+ *     import('./Formatter.js').SwitchFormatter
+ * }} cfg
+ * @returns {(string|Node)[]}
+ */
+/**
+ * Callback to return a string or array of nodes and strings based on
+ *   a localized string, substitutions object, and other metadata.
+ *
+ * `string` - The localized string.
+ * `dom` - If substitutions known to contain DOM, can be set
+ *    to `true` to optimize.
+ * `usedKeys` - Array for tracking which keys have been used. Defaults
+ *   to empty array.
+ * `substitutions` - The formatting substitutions object.
+ * `allSubstitutions` - The
+ *   callback or array composed thereof for applying to each substitution.
+ * `locale` - The successfully resolved locale
+ * `locals` - The local section.
+ * `switches` - The switch section.
+ * `maximumLocalNestingDepth` - Depth of local variable resolution to
+ *   check before reporting a recursion error. Defaults to 3.
+ * `missingSuppliedFormatters` - Callback
+ *   supplied key to throw if the supplied key is present (if
+ *   `throwOnMissingSuppliedFormatters` is enabled). Defaults to no-op.
+ * `checkExtraSuppliedFormatters` - No
+ *   argument callback to check if any formatters are not present in `string`
+ *   (if `throwOnExtraSuppliedFormatters` is enabled). Defaults to no-op.
+ * @typedef {(cfg: {
+ *   string: string,
+ *   dom?: boolean,
+ *   usedKeys: string[],
+ *   substitutions: import('./defaultLocaleResolver.js').SubstitutionObject,
+ *   allSubstitutions?: ?(
+ *     import('./defaultAllSubstitutions.js').AllSubstitutionCallback|
+ *     import('./defaultAllSubstitutions.js').AllSubstitutionCallback[]
+ *   )
+ *   locale: string|undefined,
+ *   locals?: import('./getMessageForKeyByStyle.js').LocalObject|undefined,
+ *   switches: import('./defaultLocaleResolver.js').Switches|undefined,
+ *   maximumLocalNestingDepth?: Integer,
+ *   missingSuppliedFormatters: import('./getDOMForLocaleString.js').
+ *     MissingSuppliedFormattersCallback,
+ *   checkExtraSuppliedFormatters: import('./getDOMForLocaleString.js').
+ *     CheckExtraSuppliedFormattersCallback
+ * }) => string|(Node|string)[]} InsertNodesCallback
+ */
+/**
+ * @type {InsertNodesCallback}
+ */
+export declare const defaultInsertNodes: InsertNodesCallback;
+//# sourceMappingURL=defaultInsertNodes.d.ts.map

package/vendor/intl-dom/dist/defaultInsertNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultInsertNodes.d.ts","sourceRoot":"","sources":["../src/defaultInsertNodes.js"],"names":[],"mappings":"AAOG,YAAkB,OAAO,GAAf,MAAM,CAAS;AAIzB,YAAU,OAAO,GACjB,CAMG,GAAG,EANE;IACN,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;IACjE,SAAS,CAAC,EAAE,OAAO,gBAAgB,EAAE,gBAAgB,GACzD,OAAa,gBAAgB,EAAE,cAAc,GAC7C,OAAa,gBAAgB,EAAE,eAAe,CAAA;CAE5C,KAAU,MACZ,CAAA;AAGE,YAAU,oBAAoB,GAC9B,CAMG,GAAG,EANE;IACN,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;IACjE,SAAS,CAAC,EAAE,OAAO,gBAAgB,EAAE,gBAAgB,GACzD,OAAa,gBAAgB,EAAE,cAAc,GAC7C,OAAa,gBAAgB,EAAE,eAAe,CAAA;CAE5C,KAAU,CAAC,MAAM,GAAC,IAAI,CAAC,EACzB,CAAA;AAyBE,YAiB8B,mBAAmB,GAjBvC,CAAC,GAAG,EAAE;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;IACvE,gBAAgB,CAAC,EAAG,CACxB,OAAa,8BAA8B,EAAE,uBAAuB,GACpE,OAAa,8BAA8B,EAAE,uBAAuB,EAAE,CACjE,OAAA,CAAA;IACD,MAAM,EAAE,MAAM,GAAC,SAAS,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,8BAA8B,EAAE,WAAW,GAAC,SAAS,CAAC;IACtE,QAAQ,EAAE,OAAO,4BAA4B,EAAE,QAAQ,GAAC,SAAS,CAAC;IAClE,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,EAAE,OAAO,4BAA4B,EAC5D,iCAAiC,CAAC;IACpC,4BAA4B,EAAE,OAAO,4BAA4B,EAC/D,oCAAoC,CAAA;CACvC,KAAK,MAAM,GAAC,CAAC,IAAI,GAAC,MAAM,CAAC,EAAE,CAAqB;AApEpD;;GAEG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAFrB,mBAsST,CAAC"}

package/vendor/intl-dom/dist/defaultKeyCheckerConverter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @callback KeyCheckerConverterCallback
+ * @param {string|string[]} key By default may be an array (if the type ends
+ *   with "Nested") or a string, but a non-default validator may do otherwise.
+ * @param {"plain"|"plainNested"|"rich"|
+ *   "richNested"|
+ *   import('./getMessageForKeyByStyle.js').MessageStyleCallback
+ * } messageStyle
+ * @throws {TypeError}
+ * @returns {string} The converted (or unconverted) key
+ */
+export type KeyCheckerConverterCallback = (key: string | string[], messageStyle: "plain" | "plainNested" | "rich" | "richNested" | import('./getMessageForKeyByStyle.js').MessageStyleCallback) => any;
+/**
+ * @type {KeyCheckerConverterCallback}
+ */
+export declare const defaultKeyCheckerConverter: KeyCheckerConverterCallback;
+//# sourceMappingURL=defaultKeyCheckerConverter.d.ts.map

package/vendor/intl-dom/dist/defaultKeyCheckerConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultKeyCheckerConverter.d.ts","sourceRoot":"","sources":["../src/defaultKeyCheckerConverter.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AATA,YAAU,2BAA2B,GACrC,CAAyB,GAAG,EAApB,MAAM,GAAC,MAAM,EAErB,EAGE,YAAY,EAHN,OAAO,GAAC,aAAa,GAAC,MAAM,GACtC,YAAgB,GAChB,OAAW,8BAA8B,EAAE,oBAEzC,QAAA,CAAA;AAIH;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAF7B,2BAqBT,CAAC"}