lingo.dev 0.63.2 → 0.70.1

package/build/chunk-MUWDGJF2.mjs

@@ -0,0 +1,962 @@
+import {
+  localeCodeSchema,
+  z
+} from "./chunk-DAMIL4EZ.mjs";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-HEBXNMVQ.mjs";
+
+// ../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/_assert.js
+var require_assert = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/_assert.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBytes = isBytes;
+    exports.number = number;
+    exports.bool = bool;
+    exports.bytes = bytes;
+    exports.hash = hash;
+    exports.exists = exists;
+    exports.output = output;
+    function number(n) {
+      if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error(`positive integer expected, not ${n}`);
+    }
+    function bool(b) {
+      if (typeof b !== "boolean")
+        throw new Error(`boolean expected, not ${b}`);
+    }
+    function isBytes(a) {
+      return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+    }
+    function bytes(b, ...lengths) {
+      if (!isBytes(b))
+        throw new Error("Uint8Array expected");
+      if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+    }
+    function hash(h) {
+      if (typeof h !== "function" || typeof h.create !== "function")
+        throw new Error("Hash should be wrapped by utils.wrapConstructor");
+      number(h.outputLen);
+      number(h.blockLen);
+    }
+    function exists(instance, checkFinished = true) {
+      if (instance.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (checkFinished && instance.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function output(out, instance) {
+      bytes(out);
+      const min = instance.outputLen;
+      if (out.length < min) {
+        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+      }
+    }
+    var assert = { number, bool, bytes, hash, exists, output };
+    exports.default = assert;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/_u64.js
+var require_u64 = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/_u64.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.add5L = exports.add5H = exports.add4H = exports.add4L = exports.add3H = exports.add3L = exports.rotlBL = exports.rotlBH = exports.rotlSL = exports.rotlSH = exports.rotr32L = exports.rotr32H = exports.rotrBL = exports.rotrBH = exports.rotrSL = exports.rotrSH = exports.shrSL = exports.shrSH = exports.toBig = void 0;
+    exports.fromBig = fromBig;
+    exports.split = split;
+    exports.add = add;
+    var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    var _32n = /* @__PURE__ */ BigInt(32);
+    function fromBig(n, le = false) {
+      if (le)
+        return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+      return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+    }
+    function split(lst, le = false) {
+      let Ah = new Uint32Array(lst.length);
+      let Al = new Uint32Array(lst.length);
+      for (let i = 0; i < lst.length; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+      }
+      return [Ah, Al];
+    }
+    var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+    exports.toBig = toBig;
+    var shrSH = (h, _l, s) => h >>> s;
+    exports.shrSH = shrSH;
+    var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports.shrSL = shrSL;
+    var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+    exports.rotrSH = rotrSH;
+    var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports.rotrSL = rotrSL;
+    var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+    exports.rotrBH = rotrBH;
+    var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+    exports.rotrBL = rotrBL;
+    var rotr32H = (_h, l) => l;
+    exports.rotr32H = rotr32H;
+    var rotr32L = (h, _l) => h;
+    exports.rotr32L = rotr32L;
+    var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    exports.rotlSH = rotlSH;
+    var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    exports.rotlSL = rotlSL;
+    var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    exports.rotlBH = rotlBH;
+    var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+    exports.rotlBL = rotlBL;
+    function add(Ah, Al, Bh, Bl) {
+      const l = (Al >>> 0) + (Bl >>> 0);
+      return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+    }
+    var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    exports.add3L = add3L;
+    var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+    exports.add3H = add3H;
+    var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    exports.add4L = add4L;
+    var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+    exports.add4H = add4H;
+    var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    exports.add5L = add5L;
+    var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+    exports.add5H = add5H;
+    var u64 = {
+      fromBig,
+      split,
+      toBig,
+      shrSH,
+      shrSL,
+      rotrSH,
+      rotrSL,
+      rotrBH,
+      rotrBL,
+      rotr32H,
+      rotr32L,
+      rotlSH,
+      rotlSL,
+      rotlBH,
+      rotlBL,
+      add,
+      add3L,
+      add3H,
+      add4L,
+      add4H,
+      add5H,
+      add5L
+    };
+    exports.default = u64;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/cryptoNode.js
+var require_cryptoNode = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/cryptoNode.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.crypto = void 0;
+    var nc = __require("node:crypto");
+    exports.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/utils.js
+var require_utils = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Hash = exports.nextTick = exports.byteSwapIfBE = exports.byteSwap = exports.isLE = exports.rotl = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;
+    exports.isBytes = isBytes;
+    exports.byteSwap32 = byteSwap32;
+    exports.bytesToHex = bytesToHex;
+    exports.hexToBytes = hexToBytes;
+    exports.asyncLoop = asyncLoop;
+    exports.utf8ToBytes = utf8ToBytes;
+    exports.toBytes = toBytes;
+    exports.concatBytes = concatBytes;
+    exports.checkOpts = checkOpts;
+    exports.wrapConstructor = wrapConstructor;
+    exports.wrapConstructorWithOpts = wrapConstructorWithOpts;
+    exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
+    exports.randomBytes = randomBytes;
+    var crypto_1 = require_cryptoNode();
+    var _assert_js_1 = require_assert();
+    function isBytes(a) {
+      return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+    }
+    var u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+    exports.u8 = u8;
+    var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    exports.u32 = u32;
+    var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    exports.createView = createView;
+    var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+    exports.rotr = rotr;
+    var rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
+    exports.rotl = rotl;
+    exports.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+    exports.byteSwap = byteSwap;
+    exports.byteSwapIfBE = exports.isLE ? (n) => n : (n) => (0, exports.byteSwap)(n);
+    function byteSwap32(arr) {
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = (0, exports.byteSwap)(arr[i]);
+      }
+    }
+    var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+    function bytesToHex(bytes) {
+      (0, _assert_js_1.bytes)(bytes);
+      let hex = "";
+      for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+      }
+      return hex;
+    }
+    var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+    function asciiToBase16(char) {
+      if (char >= asciis._0 && char <= asciis._9)
+        return char - asciis._0;
+      if (char >= asciis._A && char <= asciis._F)
+        return char - (asciis._A - 10);
+      if (char >= asciis._a && char <= asciis._f)
+        return char - (asciis._a - 10);
+      return;
+    }
+    function hexToBytes(hex) {
+      if (typeof hex !== "string")
+        throw new Error("hex string expected, got " + typeof hex);
+      const hl = hex.length;
+      const al = hl / 2;
+      if (hl % 2)
+        throw new Error("padded hex string expected, got unpadded hex of length " + hl);
+      const array = new Uint8Array(al);
+      for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === void 0 || n2 === void 0) {
+          const char = hex[hi] + hex[hi + 1];
+          throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2;
+      }
+      return array;
+    }
+    var nextTick = async () => {
+    };
+    exports.nextTick = nextTick;
+    async function asyncLoop(iters, tick, cb) {
+      let ts = Date.now();
+      for (let i = 0; i < iters; i++) {
+        cb(i);
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+          continue;
+        await (0, exports.nextTick)();
+        ts += diff;
+      }
+    }
+    function utf8ToBytes(str) {
+      if (typeof str !== "string")
+        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+      return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function toBytes(data) {
+      if (typeof data === "string")
+        data = utf8ToBytes(data);
+      (0, _assert_js_1.bytes)(data);
+      return data;
+    }
+    function concatBytes(...arrays) {
+      let sum = 0;
+      for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        (0, _assert_js_1.bytes)(a);
+        sum += a.length;
+      }
+      const res = new Uint8Array(sum);
+      for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+      }
+      return res;
+    }
+    var Hash = class {
+      // Safe version that clones internal state
+      clone() {
+        return this._cloneInto();
+      }
+    };
+    exports.Hash = Hash;
+    var toStr = {}.toString;
+    function checkOpts(defaults, opts) {
+      if (opts !== void 0 && toStr.call(opts) !== "[object Object]")
+        throw new Error("Options should be object or undefined");
+      const merged = Object.assign(defaults, opts);
+      return merged;
+    }
+    function wrapConstructor(hashCons) {
+      const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+      const tmp = hashCons();
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = () => hashCons();
+      return hashC;
+    }
+    function wrapConstructorWithOpts(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    function wrapXOFConstructorWithOpts(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    function randomBytes(bytesLength = 32) {
+      if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+      }
+      if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
+        return crypto_1.crypto.randomBytes(bytesLength);
+      }
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/sha3.js
+var require_sha3 = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/sha3.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.sha3_512 = exports.sha3_384 = exports.sha3_256 = exports.sha3_224 = exports.Keccak = void 0;
+    exports.keccakP = keccakP;
+    var _assert_js_1 = require_assert();
+    var _u64_js_1 = require_u64();
+    var utils_js_1 = require_utils();
+    var SHA3_PI = [];
+    var SHA3_ROTL = [];
+    var _SHA3_IOTA = [];
+    var _0n = /* @__PURE__ */ BigInt(0);
+    var _1n = /* @__PURE__ */ BigInt(1);
+    var _2n = /* @__PURE__ */ BigInt(2);
+    var _7n = /* @__PURE__ */ BigInt(7);
+    var _256n = /* @__PURE__ */ BigInt(256);
+    var _0x71n = /* @__PURE__ */ BigInt(113);
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    var [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ (0, _u64_js_1.split)(_SHA3_IOTA, true);
+    var rotlH = (h, l, s) => s > 32 ? (0, _u64_js_1.rotlBH)(h, l, s) : (0, _u64_js_1.rotlSH)(h, l, s);
+    var rotlL = (h, l, s) => s > 32 ? (0, _u64_js_1.rotlBL)(h, l, s) : (0, _u64_js_1.rotlSL)(h, l, s);
+    function keccakP(s, rounds = 24) {
+      const B = new Uint32Array(5 * 2);
+      for (let round = 24 - rounds; round < 24; round++) {
+        for (let x = 0; x < 10; x++)
+          B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+          const idx1 = (x + 8) % 10;
+          const idx0 = (x + 2) % 10;
+          const B0 = B[idx0];
+          const B1 = B[idx0 + 1];
+          const Th = rotlH(B0, B1, 1) ^ B[idx1];
+          const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+          for (let y = 0; y < 50; y += 10) {
+            s[x + y] ^= Th;
+            s[x + y + 1] ^= Tl;
+          }
+        }
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+          const shift = SHA3_ROTL[t];
+          const Th = rotlH(curH, curL, shift);
+          const Tl = rotlL(curH, curL, shift);
+          const PI = SHA3_PI[t];
+          curH = s[PI];
+          curL = s[PI + 1];
+          s[PI] = Th;
+          s[PI + 1] = Tl;
+        }
+        for (let y = 0; y < 50; y += 10) {
+          for (let x = 0; x < 10; x++)
+            B[x] = s[y + x];
+          for (let x = 0; x < 10; x++)
+            s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+      }
+      B.fill(0);
+    }
+    var Keccak = class _Keccak extends utils_js_1.Hash {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        (0, _assert_js_1.number)(outputLen);
+        if (0 >= this.blockLen || this.blockLen >= 200)
+          throw new Error("Sha3 supports only keccak-f1600 function");
+        this.state = new Uint8Array(200);
+        this.state32 = (0, utils_js_1.u32)(this.state);
+      }
+      keccak() {
+        if (!utils_js_1.isLE)
+          (0, utils_js_1.byteSwap32)(this.state32);
+        keccakP(this.state32, this.rounds);
+        if (!utils_js_1.isLE)
+          (0, utils_js_1.byteSwap32)(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        (0, _assert_js_1.exists)(this);
+        const { blockLen, state } = this;
+        data = (0, utils_js_1.toBytes)(data);
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        (0, _assert_js_1.exists)(this, false);
+        (0, _assert_js_1.bytes)(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        (0, _assert_js_1.number)(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        (0, _assert_js_1.output)(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+      destroy() {
+        this.destroyed = true;
+        this.state.fill(0);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    exports.Keccak = Keccak;
+    var gen = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapConstructor)(() => new Keccak(blockLen, suffix, outputLen));
+    exports.sha3_224 = gen(6, 144, 224 / 8);
+    exports.sha3_256 = gen(6, 136, 256 / 8);
+    exports.sha3_384 = gen(6, 104, 384 / 8);
+    exports.sha3_512 = gen(6, 72, 512 / 8);
+    exports.keccak_224 = gen(1, 144, 224 / 8);
+    exports.keccak_256 = gen(1, 136, 256 / 8);
+    exports.keccak_384 = gen(1, 104, 384 / 8);
+    exports.keccak_512 = gen(1, 72, 512 / 8);
+    var genShake = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapXOFConstructorWithOpts)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+    exports.shake128 = genShake(31, 168, 128 / 8);
+    exports.shake256 = genShake(31, 136, 256 / 8);
+  }
+});
+
+// ../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/src/index.js
+var require_src = __commonJS({
+  "../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/src/index.js"(exports, module) {
+    "use strict";
+    var { sha3_512: sha3 } = require_sha3();
+    var defaultLength = 24;
+    var bigLength = 32;
+    var createEntropy = (length = 4, random = Math.random) => {
+      let entropy = "";
+      while (entropy.length < length) {
+        entropy = entropy + Math.floor(random() * 36).toString(36);
+      }
+      return entropy;
+    };
+    function bufToBigInt(buf) {
+      let bits = 8n;
+      let value = 0n;
+      for (const i of buf.values()) {
+        const bi = BigInt(i);
+        value = (value << bits) + bi;
+      }
+      return value;
+    }
+    var hash = (input = "") => {
+      return bufToBigInt(sha3(input)).toString(36).slice(1);
+    };
+    var alphabet = Array.from(
+      { length: 26 },
+      (x, i) => String.fromCharCode(i + 97)
+    );
+    var randomLetter = (random) => alphabet[Math.floor(random() * alphabet.length)];
+    var createFingerprint = ({
+      globalObj = typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : {},
+      random = Math.random
+    } = {}) => {
+      const globals = Object.keys(globalObj).toString();
+      const sourceString = globals.length ? globals + createEntropy(bigLength, random) : createEntropy(bigLength, random);
+      return hash(sourceString).substring(0, bigLength);
+    };
+    var createCounter = (count) => () => {
+      return count++;
+    };
+    var initialCountMax = 476782367;
+    var init = ({
+      // Fallback if the user does not pass in a CSPRNG. This should be OK
+      // because we don't rely solely on the random number generator for entropy.
+      // We also use the host fingerprint, current time, and a session counter.
+      random = Math.random,
+      counter = createCounter(Math.floor(random() * initialCountMax)),
+      length = defaultLength,
+      fingerprint = createFingerprint({ random })
+    } = {}) => {
+      return function cuid2() {
+        const firstLetter = randomLetter(random);
+        const time = Date.now().toString(36);
+        const count = counter().toString(36);
+        const salt = createEntropy(length, random);
+        const hashInput = `${time + salt + count + fingerprint}`;
+        return `${firstLetter + hash(hashInput).substring(1, length)}`;
+      };
+    };
+    var createId2 = init();
+    var isCuid = (id, { minLength = 2, maxLength = bigLength } = {}) => {
+      const length = id.length;
+      const regex = /^[0-9a-z]+$/;
+      try {
+        if (typeof id === "string" && length >= minLength && length <= maxLength && regex.test(id))
+          return true;
+      } finally {
+      }
+      return false;
+    };
+    module.exports.getConstants = () => ({ defaultLength, bigLength });
+    module.exports.init = init;
+    module.exports.createId = createId2;
+    module.exports.bufToBigInt = bufToBigInt;
+    module.exports.createCounter = createCounter;
+    module.exports.createFingerprint = createFingerprint;
+    module.exports.isCuid = isCuid;
+  }
+});
+
+// ../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/index.js
+var require_cuid2 = __commonJS({
+  "../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/index.js"(exports, module) {
+    "use strict";
+    var { createId: createId2, init, getConstants, isCuid } = require_src();
+    module.exports.createId = createId2;
+    module.exports.init = init;
+    module.exports.getConstants = getConstants;
+    module.exports.isCuid = isCuid;
+  }
+});
+
+// ../packages/sdk/build/index.mjs
+var import_cuid2 = __toESM(require_cuid2(), 1);
+var engineParamsSchema = z.object({
+  apiKey: z.string(),
+  apiUrl: z.string().url().default("https://engine.replexica.com"),
+  batchSize: z.number().int().gt(0).lte(250).default(25),
+  idealBatchItemSize: z.number().int().gt(0).lte(2500).default(250)
+}).passthrough();
+var payloadSchema = z.record(z.string(), z.any());
+var localizationParamsSchema = z.object({
+  sourceLocale: localeCodeSchema,
+  targetLocale: localeCodeSchema,
+  fast: z.boolean().optional()
+});
+var referenceSchema = z.record(localeCodeSchema, payloadSchema);
+var ReplexicaEngine = class {
+  config;
+  /**
+   * Create a new ReplexicaEngine instance
+   * @param config - Configuration options for the Engine
+   */
+  constructor(config) {
+    this.config = engineParamsSchema.parse(config);
+  }
+  /**
+   * Localize content using the Replexica API
+   * @param payload - The content to be localized
+   * @param params - Localization parameters including source/target locales and fast mode option
+   * @param reference - Optional reference translations to maintain consistency
+   * @param progressCallback - Optional callback function to report progress (0-100)
+   * @returns Localized content
+   * @internal
+   */
+  async _localizeRaw(payload, params, reference, progressCallback) {
+    const finalPayload = payloadSchema.parse(payload);
+    const finalParams = localizationParamsSchema.parse(params);
+    const chunkedPayload = this.extractPayloadChunks(finalPayload);
+    const processedPayloadChunks = [];
+    const workflowId = (0, import_cuid2.createId)();
+    for (let i = 0; i < chunkedPayload.length; i++) {
+      const chunk = chunkedPayload[i];
+      const percentageCompleted = Math.round((i + 1) / chunkedPayload.length * 100);
+      if (progressCallback) {
+        progressCallback(percentageCompleted);
+      }
+      const processedPayloadChunk = await this.localizeChunk(
+        finalParams.sourceLocale,
+        finalParams.targetLocale,
+        { data: chunk, reference },
+        workflowId,
+        params.fast || false
+      );
+      processedPayloadChunks.push(processedPayloadChunk);
+    }
+    return Object.assign({}, ...processedPayloadChunks);
+  }
+  /**
+   * Localize a single chunk of content
+   * @param sourceLocale - Source locale
+   * @param targetLocale - Target locale
+   * @param payload - Payload containing the chunk to be localized
+   * @returns Localized chunk
+   */
+  async localizeChunk(sourceLocale, targetLocale, payload, workflowId, fast) {
+    const res = await fetch(`${this.config.apiUrl}/i18n`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify(
+        {
+          params: { workflowId, fast },
+          locale: {
+            source: sourceLocale,
+            target: targetLocale
+          },
+          data: payload.data,
+          reference: payload.reference
+        },
+        null,
+        2
+      )
+    });
+    if (!res.ok) {
+      if (res.status === 400) {
+        throw new Error(`Invalid request: ${res.statusText}`);
+      } else {
+        const errorText = await res.text();
+        throw new Error(errorText);
+      }
+    }
+    const jsonResponse = await res.json();
+    return jsonResponse.data || {};
+  }
+  /**
+   * Extract payload chunks based on the ideal chunk size
+   * @param payload - The payload to be chunked
+   * @returns An array of payload chunks
+   */
+  extractPayloadChunks(payload) {
+    const result = [];
+    let currentChunk = {};
+    let currentChunkItemCount = 0;
+    const payloadEntries = Object.entries(payload);
+    for (let i = 0; i < payloadEntries.length; i++) {
+      const [key, value] = payloadEntries[i];
+      currentChunk[key] = value;
+      currentChunkItemCount++;
+      const currentChunkSize = this.countWordsInRecord(currentChunk);
+      if (currentChunkSize > this.config.idealBatchItemSize || currentChunkItemCount >= this.config.batchSize || i === payloadEntries.length - 1) {
+        result.push(currentChunk);
+        currentChunk = {};
+        currentChunkItemCount = 0;
+      }
+    }
+    return result;
+  }
+  /**
+   * Count words in a record or array
+   * @param payload - The payload to count words in
+   * @returns The total number of words
+   */
+  countWordsInRecord(payload) {
+    if (Array.isArray(payload)) {
+      return payload.reduce((acc, item) => acc + this.countWordsInRecord(item), 0);
+    } else if (typeof payload === "object" && payload !== null) {
+      return Object.values(payload).reduce((acc, item) => acc + this.countWordsInRecord(item), 0);
+    } else if (typeof payload === "string") {
+      return payload.trim().split(/\s+/).filter(Boolean).length;
+    } else {
+      return 0;
+    }
+  }
+  /**
+   * Localize a typical JavaScript object
+   * @param obj - The object to be localized (strings will be extracted and translated)
+   * @param params - Localization parameters:
+   *   - sourceLocale: The source language code (e.g., 'en')
+   *   - targetLocale: The target language code (e.g., 'es')
+   *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
+   * @param progressCallback - Optional callback function to report progress (0-100)
+   * @returns A new object with the same structure but localized string values
+   */
+  async localizeObject(obj, params, progressCallback) {
+    return this._localizeRaw(obj, params, void 0, progressCallback);
+  }
+  /**
+   * Localize a single text string
+   * @param text - The text string to be localized
+   * @param params - Localization parameters:
+   *   - sourceLocale: The source language code (e.g., 'en')
+   *   - targetLocale: The target language code (e.g., 'es')
+   *   - fast: Optional boolean to enable fast mode (faster for bigger batches)
+   * @param progressCallback - Optional callback function to report progress (0-100)
+   * @returns The localized text string
+   */
+  async localizeText(text, params, progressCallback) {
+    const response = await this._localizeRaw({ text }, params, void 0, progressCallback);
+    return response.text || "";
+  }
+  /**
+   * Localize a text string to multiple target locales
+   * @param text - The text string to be localized
+   * @param params - Localization parameters:
+   *   - sourceLocale: The source language code (e.g., 'en')
+   *   - targetLocales: An array of target language codes (e.g., ['es', 'fr'])
+   *   - fast: Optional boolean to enable fast mode (for bigger batches)
+   * @returns An array of localized text strings
+   */
+  async batchLocalizeText(text, params) {
+    const responses = await Promise.all(
+      params.targetLocales.map(
+        (targetLocale) => this.localizeText(text, {
+          sourceLocale: params.sourceLocale,
+          targetLocale,
+          fast: params.fast
+        })
+      )
+    );
+    return responses;
+  }
+  /**
+   * Localize a chat sequence while preserving speaker names
+   * @param chat - Array of chat messages, each with 'name' and 'text' properties
+   * @param params - Localization parameters:
+   *   - sourceLocale: The source language code (e.g., 'en')
+   *   - targetLocale: The target language code (e.g., 'es')
+   *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
+   * @param progressCallback - Optional callback function to report progress (0-100)
+   * @returns Array of localized chat messages with preserved structure
+   */
+  async localizeChat(chat, params, progressCallback) {
+    const localized = await this._localizeRaw({ chat }, params, void 0, progressCallback);
+    return Object.entries(localized).map(([key, value]) => ({
+      name: chat[parseInt(key.split("_")[1])].name,
+      text: value
+    }));
+  }
+  /**
+   * Localize an HTML document while preserving structure and formatting
+   * Handles both text content and localizable attributes (alt, title, placeholder, meta content)
+   * @param html - The HTML document string to be localized
+   * @param params - Localization parameters:
+   *   - sourceLocale: The source language code (e.g., 'en')
+   *   - targetLocale: The target language code (e.g., 'es')
+   *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
+   * @param progressCallback - Optional callback function to report progress (0-100)
+   * @returns The localized HTML document as a string, with updated lang attribute
+   */
+  async localizeHtml(html, params, progressCallback) {
+    const jsdomPackage = await import("./api-7PZYRHW3.mjs");
+    const { JSDOM } = jsdomPackage;
+    const dom = new JSDOM(html);
+    const document = dom.window.document;
+    const LOCALIZABLE_ATTRIBUTES = {
+      meta: ["content"],
+      img: ["alt"],
+      input: ["placeholder"],
+      a: ["title"]
+    };
+    const UNLOCALIZABLE_TAGS = ["script", "style"];
+    const extractedContent = {};
+    const getPath = (node, attribute) => {
+      const indices = [];
+      let current = node;
+      let rootParent = "";
+      while (current) {
+        const parent = current.parentElement;
+        if (!parent) break;
+        if (parent === document.documentElement) {
+          rootParent = current.nodeName.toLowerCase();
+          break;
+        }
+        const siblings = Array.from(parent.childNodes).filter(
+          (n) => n.nodeType === 1 || n.nodeType === 3 && n.textContent?.trim()
+        );
+        const index = siblings.indexOf(current);
+        if (index !== -1) {
+          indices.unshift(index);
+        }
+        current = parent;
+      }
+      const basePath = rootParent ? `${rootParent}/${indices.join("/")}` : indices.join("/");
+      return attribute ? `${basePath}#${attribute}` : basePath;
+    };
+    const processNode = (node) => {
+      let parent = node.parentElement;
+      while (parent) {
+        if (UNLOCALIZABLE_TAGS.includes(parent.tagName.toLowerCase())) {
+          return;
+        }
+        parent = parent.parentElement;
+      }
+      if (node.nodeType === 3) {
+        const text = node.textContent?.trim() || "";
+        if (text) {
+          extractedContent[getPath(node)] = text;
+        }
+      } else if (node.nodeType === 1) {
+        const element = node;
+        const tagName = element.tagName.toLowerCase();
+        const attributes = LOCALIZABLE_ATTRIBUTES[tagName] || [];
+        attributes.forEach((attr) => {
+          const value = element.getAttribute(attr);
+          if (value) {
+            extractedContent[getPath(element, attr)] = value;
+          }
+        });
+        Array.from(element.childNodes).filter((n) => n.nodeType === 1 || n.nodeType === 3 && n.textContent?.trim()).forEach(processNode);
+      }
+    };
+    Array.from(document.head.childNodes).filter((n) => n.nodeType === 1 || n.nodeType === 3 && n.textContent?.trim()).forEach(processNode);
+    Array.from(document.body.childNodes).filter((n) => n.nodeType === 1 || n.nodeType === 3 && n.textContent?.trim()).forEach(processNode);
+    const localizedContent = await this._localizeRaw(extractedContent, params, void 0, progressCallback);
+    document.documentElement.setAttribute("lang", params.targetLocale);
+    Object.entries(localizedContent).forEach(([path, value]) => {
+      const [nodePath, attribute] = path.split("#");
+      const [rootTag, ...indices] = nodePath.split("/");
+      let parent = rootTag === "head" ? document.head : document.body;
+      let current = parent;
+      for (const index of indices) {
+        const siblings = Array.from(parent.childNodes).filter(
+          (n) => n.nodeType === 1 || n.nodeType === 3 && n.textContent?.trim()
+        );
+        current = siblings[parseInt(index)] || null;
+        if (current?.nodeType === 1) {
+          parent = current;
+        }
+      }
+      if (current) {
+        if (attribute) {
+          current.setAttribute(attribute, value);
+        } else {
+          current.textContent = value;
+        }
+      }
+    });
+    return dom.serialize();
+  }
+  /**
+   * Detect the language of a given text
+   * @param text - The text to analyze
+   * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
+   */
+  async recognizeLocale(text) {
+    const response = await fetch(`${this.config.apiUrl}/recognize`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify({ text })
+    });
+    if (!response.ok) {
+      throw new Error(`Error recognizing locale: ${response.statusText}`);
+    }
+    const jsonResponse = await response.json();
+    return jsonResponse.locale;
+  }
+};
+
+export {
+  ReplexicaEngine
+};
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/