@zylem/game-lib 0.4.1 → 0.5.0

package/dist/node_modules/.pnpm/msgpackr@1.11.5/node_modules/msgpackr/pack.js

@@ -0,0 +1,520 @@
+import { Unpackr as le, mult10 as oe, C1Type as xe, typedArrays as ce } from "./unpack.js";
+let C;
+try {
+  C = new TextEncoder();
+} catch {
+}
+let j, se;
+const R = typeof Buffer < "u", D = R ? function(c) {
+  return Buffer.allocUnsafeSlow(c);
+} : Uint8Array, re = R ? Buffer : Uint8Array, ee = R ? 4294967296 : 2144337920;
+let t, M, m, e = 0, I, S = null, he;
+const ae = 21760, ue = /[\u0080-\uFFFF]/, A = Symbol("record-id");
+class de extends le {
+  constructor(o) {
+    super(o), this.offset = 0;
+    let s, h, r, g, w = re.prototype.utf8Write ? function(i, x) {
+      return t.utf8Write(i, x, t.byteLength - x);
+    } : C && C.encodeInto ? function(i, x) {
+      return C.encodeInto(i, t.subarray(x)).written;
+    } : !1, k = this;
+    o || (o = {});
+    let z = o && o.sequential, G = o.structures || o.saveStructures, O = o.maxSharedStructures;
+    if (O == null && (O = G ? 32 : 0), O > 8160)
+      throw new Error("Maximum maxSharedStructure is 8160");
+    o.structuredClone && o.moreTypes == null && (this.moreTypes = !0);
+    let P = o.maxOwnStructures;
+    P == null && (P = G ? 32 : 64), !this.structures && o.useRecords != !1 && (this.structures = []);
+    let F = O > 32 || P + O > 64, L = O + 64, K = O + P + 64;
+    if (K > 8256)
+      throw new Error("Maximum maxSharedStructure + maxOwnStructure is 8192");
+    let T = [], q = 0, _ = 0;
+    this.pack = this.encode = function(i, x) {
+      if (t || (t = new D(8192), m = t.dataView || (t.dataView = new DataView(t.buffer, 0, 8192)), e = 0), I = t.length - 10, I - e < 2048 ? (t = new D(t.length), m = t.dataView || (t.dataView = new DataView(t.buffer, 0, t.length)), I = t.length - 10, e = 0) : e = e + 7 & 2147483640, s = e, x & me && (e += x & 255), g = k.structuredClone ? /* @__PURE__ */ new Map() : null, k.bundleStrings && typeof i != "string" ? (S = [], S.size = 1 / 0) : S = null, r = k.structures, r) {
+        r.uninitialized && (r = k._mergeStructures(k.getStructures()));
+        let n = r.sharedLength || 0;
+        if (n > O)
+          throw new Error("Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to " + r.sharedLength);
+        if (!r.transitions) {
+          r.transitions = /* @__PURE__ */ Object.create(null);
+          for (let f = 0; f < n; f++) {
+            let u = r[f];
+            if (!u)
+              continue;
+            let d, a = r.transitions;
+            for (let y = 0, p = u.length; y < p; y++) {
+              let B = u[y];
+              d = a[B], d || (d = a[B] = /* @__PURE__ */ Object.create(null)), a = d;
+            }
+            a[A] = f + 64;
+          }
+          this.lastNamedStructuresLength = n;
+        }
+        z || (r.nextId = n + 64);
+      }
+      h && (h = !1);
+      let l;
+      try {
+        k.randomAccessStructure && i && i.constructor && i.constructor === Object ? fe(i) : b(i);
+        let n = S;
+        if (S && ie(s, b, 0), g && g.idsToInsert) {
+          let f = g.idsToInsert.sort((y, p) => y.offset > p.offset ? 1 : -1), u = f.length, d = -1;
+          for (; n && u > 0; ) {
+            let y = f[--u].offset + s;
+            y < n.stringsPosition + s && d === -1 && (d = 0), y > n.position + s ? d >= 0 && (d += 6) : (d >= 0 && (m.setUint32(
+              n.position + s,
+              m.getUint32(n.position + s) + d
+            ), d = -1), n = n.previous, u++);
+          }
+          d >= 0 && n && m.setUint32(
+            n.position + s,
+            m.getUint32(n.position + s) + d
+          ), e += f.length * 6, e > I && U(e), k.offset = e;
+          let a = ge(t.subarray(s, e), f);
+          return g = null, a;
+        }
+        return k.offset = e, x & ye ? (t.start = s, t.end = e, t) : t.subarray(s, e);
+      } catch (n) {
+        throw l = n, n;
+      } finally {
+        if (r && (H(), h && k.saveStructures)) {
+          let n = r.sharedLength || 0, f = t.subarray(s, e), u = we(r, k);
+          if (!l)
+            return k.saveStructures(u, u.isCompatible) === !1 ? k.pack(i, x) : (k.lastNamedStructuresLength = n, t.length > 1073741824 && (t = null), f);
+        }
+        t.length > 1073741824 && (t = null), x & pe && (e = s);
+      }
+    };
+    const H = () => {
+      _ < 10 && _++;
+      let i = r.sharedLength || 0;
+      if (r.length > i && !z && (r.length = i), q > 1e4)
+        r.transitions = null, _ = 0, q = 0, T.length > 0 && (T = []);
+      else if (T.length > 0 && !z) {
+        for (let x = 0, l = T.length; x < l; x++)
+          T[x][A] = 0;
+        T = [];
+      }
+    }, J = (i) => {
+      var x = i.length;
+      x < 16 ? t[e++] = 144 | x : x < 65536 ? (t[e++] = 220, t[e++] = x >> 8, t[e++] = x & 255) : (t[e++] = 221, m.setUint32(e, x), e += 4);
+      for (let l = 0; l < x; l++)
+        b(i[l]);
+    }, b = (i) => {
+      e > I && (t = U(e));
+      var x = typeof i, l;
+      if (x === "string") {
+        let n = i.length;
+        if (S && n >= 4 && n < 4096) {
+          if ((S.size += n) > ae) {
+            let a, y = (S[0] ? S[0].length * 3 + S[1].length : 0) + 10;
+            e + y > I && (t = U(e + y));
+            let p;
+            S.position ? (p = S, t[e] = 200, e += 3, t[e++] = 98, a = e - s, e += 4, ie(s, b, 0), m.setUint16(a + s - 3, e - s - a)) : (t[e++] = 214, t[e++] = 98, a = e - s, e += 4), S = ["", ""], S.previous = p, S.size = 0, S.position = a;
+          }
+          let d = ue.test(i);
+          S[d ? 0 : 1] += i, t[e++] = 193, b(d ? -n : n);
+          return;
+        }
+        let f;
+        n < 32 ? f = 1 : n < 256 ? f = 2 : n < 65536 ? f = 3 : f = 5;
+        let u = n * 3;
+        if (e + u > I && (t = U(e + u)), n < 64 || !w) {
+          let d, a, y, p = e + f;
+          for (d = 0; d < n; d++)
+            a = i.charCodeAt(d), a < 128 ? t[p++] = a : a < 2048 ? (t[p++] = a >> 6 | 192, t[p++] = a & 63 | 128) : (a & 64512) === 55296 && ((y = i.charCodeAt(d + 1)) & 64512) === 56320 ? (a = 65536 + ((a & 1023) << 10) + (y & 1023), d++, t[p++] = a >> 18 | 240, t[p++] = a >> 12 & 63 | 128, t[p++] = a >> 6 & 63 | 128, t[p++] = a & 63 | 128) : (t[p++] = a >> 12 | 224, t[p++] = a >> 6 & 63 | 128, t[p++] = a & 63 | 128);
+          l = p - e - f;
+        } else
+          l = w(i, e + f);
+        l < 32 ? t[e++] = 160 | l : l < 256 ? (f < 2 && t.copyWithin(e + 2, e + 1, e + 1 + l), t[e++] = 217, t[e++] = l) : l < 65536 ? (f < 3 && t.copyWithin(e + 3, e + 2, e + 2 + l), t[e++] = 218, t[e++] = l >> 8, t[e++] = l & 255) : (f < 5 && t.copyWithin(e + 5, e + 3, e + 3 + l), t[e++] = 219, m.setUint32(e, l), e += 4), e += l;
+      } else if (x === "number")
+        if (i >>> 0 === i)
+          i < 32 || i < 128 && this.useRecords === !1 || i < 64 && !this.randomAccessStructure ? t[e++] = i : i < 256 ? (t[e++] = 204, t[e++] = i) : i < 65536 ? (t[e++] = 205, t[e++] = i >> 8, t[e++] = i & 255) : (t[e++] = 206, m.setUint32(e, i), e += 4);
+        else if (i >> 0 === i)
+          i >= -32 ? t[e++] = 256 + i : i >= -128 ? (t[e++] = 208, t[e++] = i + 256) : i >= -32768 ? (t[e++] = 209, m.setInt16(e, i), e += 2) : (t[e++] = 210, m.setInt32(e, i), e += 4);
+        else {
+          let n;
+          if ((n = this.useFloat32) > 0 && i < 4294967296 && i >= -2147483648) {
+            t[e++] = 202, m.setFloat32(e, i);
+            let f;
+            if (n < 4 || // this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
+            (f = i * oe[(t[e] & 127) << 1 | t[e + 1] >> 7]) >> 0 === f) {
+              e += 4;
+              return;
+            } else
+              e--;
+          }
+          t[e++] = 203, m.setFloat64(e, i), e += 8;
+        }
+      else if (x === "object" || x === "function")
+        if (!i)
+          t[e++] = 192;
+        else {
+          if (g) {
+            let f = g.get(i);
+            if (f) {
+              if (!f.id) {
+                let u = g.idsToInsert || (g.idsToInsert = []);
+                f.id = u.push(f);
+              }
+              t[e++] = 214, t[e++] = 112, m.setUint32(e, f.id), e += 4;
+              return;
+            } else
+              g.set(i, { offset: e - s });
+          }
+          let n = i.constructor;
+          if (n === Object)
+            N(i);
+          else if (n === Array)
+            J(i);
+          else if (n === Map)
+            if (this.mapAsEmptyObject) t[e++] = 128;
+            else {
+              l = i.size, l < 16 ? t[e++] = 128 | l : l < 65536 ? (t[e++] = 222, t[e++] = l >> 8, t[e++] = l & 255) : (t[e++] = 223, m.setUint32(e, l), e += 4);
+              for (let [f, u] of i)
+                b(f), b(u);
+            }
+          else {
+            for (let f = 0, u = j.length; f < u; f++) {
+              let d = se[f];
+              if (i instanceof d) {
+                let a = j[f];
+                if (a.write) {
+                  a.type && (t[e++] = 212, t[e++] = a.type, t[e++] = 0);
+                  let V = a.write.call(this, i);
+                  V === i ? Array.isArray(i) ? J(i) : N(i) : b(V);
+                  return;
+                }
+                let y = t, p = m, B = e;
+                t = null;
+                let E;
+                try {
+                  E = a.pack.call(this, i, (V) => (t = y, y = null, e += V, e > I && U(e), {
+                    target: t,
+                    targetView: m,
+                    position: e - V
+                  }), b);
+                } finally {
+                  y && (t = y, m = p, e = B, I = t.length - 10);
+                }
+                E && (E.length + e > I && U(E.length + e), e = te(E, t, e, a.type));
+                return;
+              }
+            }
+            if (Array.isArray(i))
+              J(i);
+            else {
+              if (i.toJSON) {
+                const f = i.toJSON();
+                if (f !== i)
+                  return b(f);
+              }
+              if (x === "function")
+                return b(this.writeFunction && this.writeFunction(i));
+              N(i);
+            }
+          }
+        }
+      else if (x === "boolean")
+        t[e++] = i ? 195 : 194;
+      else if (x === "bigint") {
+        if (i < 9223372036854776e3 && i >= -9223372036854776e3)
+          t[e++] = 211, m.setBigInt64(e, i);
+        else if (i < 18446744073709552e3 && i > 0)
+          t[e++] = 207, m.setBigUint64(e, i);
+        else if (this.largeBigIntToFloat)
+          t[e++] = 203, m.setFloat64(e, Number(i));
+        else {
+          if (this.largeBigIntToString)
+            return b(i.toString());
+          if (this.useBigIntExtension || this.moreTypes) {
+            let n = i < 0 ? BigInt(-1) : BigInt(0), f;
+            if (i >> BigInt(65536) === n) {
+              let u = BigInt(18446744073709552e3) - BigInt(1), d = [];
+              for (; d.push(i & u), i >> BigInt(63) !== n; )
+                i >>= BigInt(64);
+              f = new Uint8Array(new BigUint64Array(d).buffer), f.reverse();
+            } else {
+              let u = i < 0, d = (u ? ~i : i).toString(16);
+              if (d.length % 2 ? d = "0" + d : parseInt(d.charAt(0), 16) >= 8 && (d = "00" + d), R)
+                f = Buffer.from(d, "hex");
+              else {
+                f = new Uint8Array(d.length / 2);
+                for (let a = 0; a < f.length; a++)
+                  f[a] = parseInt(d.slice(a * 2, a * 2 + 2), 16);
+              }
+              if (u)
+                for (let a = 0; a < f.length; a++) f[a] = ~f[a];
+            }
+            f.length + e > I && U(f.length + e), e = te(f, t, e, 66);
+            return;
+          } else
+            throw new RangeError(i + " was too large to fit in MessagePack 64-bit integer format, use useBigIntExtension, or set largeBigIntToFloat to convert to float-64, or set largeBigIntToString to convert to string");
+        }
+        e += 8;
+      } else if (x === "undefined")
+        this.encodeUndefinedAsNil ? t[e++] = 192 : (t[e++] = 212, t[e++] = 0, t[e++] = 0);
+      else
+        throw new Error("Unknown type: " + x);
+    }, Q = this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues ? (i) => {
+      let x;
+      if (this.skipValues) {
+        x = [];
+        for (let f in i)
+          (typeof i.hasOwnProperty != "function" || i.hasOwnProperty(f)) && !this.skipValues.includes(i[f]) && x.push(f);
+      } else
+        x = Object.keys(i);
+      let l = x.length;
+      l < 16 ? t[e++] = 128 | l : l < 65536 ? (t[e++] = 222, t[e++] = l >> 8, t[e++] = l & 255) : (t[e++] = 223, m.setUint32(e, l), e += 4);
+      let n;
+      if (this.coercibleKeyAsNumber)
+        for (let f = 0; f < l; f++) {
+          n = x[f];
+          let u = Number(n);
+          b(isNaN(u) ? n : u), b(i[n]);
+        }
+      else
+        for (let f = 0; f < l; f++)
+          b(n = x[f]), b(i[n]);
+    } : (i) => {
+      t[e++] = 222;
+      let x = e - s;
+      e += 2;
+      let l = 0;
+      for (let n in i)
+        (typeof i.hasOwnProperty != "function" || i.hasOwnProperty(n)) && (b(n), b(i[n]), l++);
+      if (l > 65535)
+        throw new Error('Object is too large to serialize with fast 16-bit map size, use the "variableMapSize" option to serialize this object');
+      t[x++ + s] = l >> 8, t[x + s] = l & 255;
+    }, $ = this.useRecords === !1 ? Q : o.progressiveRecords && !F ? (
+      // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
+      (i) => {
+        let x, l = r.transitions || (r.transitions = /* @__PURE__ */ Object.create(null)), n = e++ - s, f;
+        for (let u in i)
+          if (typeof i.hasOwnProperty != "function" || i.hasOwnProperty(u)) {
+            if (x = l[u], x)
+              l = x;
+            else {
+              let d = Object.keys(i), a = l;
+              l = r.transitions;
+              let y = 0;
+              for (let p = 0, B = d.length; p < B; p++) {
+                let E = d[p];
+                x = l[E], x || (x = l[E] = /* @__PURE__ */ Object.create(null), y++), l = x;
+              }
+              n + s + 1 == e ? (e--, X(l, d, y)) : v(l, d, n, y), f = !0, l = a[u];
+            }
+            b(i[u]);
+          }
+        if (!f) {
+          let u = l[A];
+          u ? t[n + s] = u : v(l, Object.keys(i), n, 0);
+        }
+      }
+    ) : (i) => {
+      let x, l = r.transitions || (r.transitions = /* @__PURE__ */ Object.create(null)), n = 0;
+      for (let u in i) (typeof i.hasOwnProperty != "function" || i.hasOwnProperty(u)) && (x = l[u], x || (x = l[u] = /* @__PURE__ */ Object.create(null), n++), l = x);
+      let f = l[A];
+      f ? f >= 96 && F ? (t[e++] = ((f -= 96) & 31) + 96, t[e++] = f >> 5) : t[e++] = f : X(l, l.__keys__ || Object.keys(i), n);
+      for (let u in i)
+        (typeof i.hasOwnProperty != "function" || i.hasOwnProperty(u)) && b(i[u]);
+    }, W = typeof this.useRecords == "function" && this.useRecords, N = W ? (i) => {
+      W(i) ? $(i) : Q(i);
+    } : $, U = (i) => {
+      let x;
+      if (i > 16777216) {
+        if (i - s > ee)
+          throw new Error("Packed buffer would be larger than maximum buffer size");
+        x = Math.min(
+          ee,
+          Math.round(Math.max((i - s) * (i > 67108864 ? 1.25 : 2), 4194304) / 4096) * 4096
+        );
+      } else
+        x = (Math.max(i - s << 2, t.length - 1) >> 12) + 1 << 12;
+      let l = new D(x);
+      return m = l.dataView || (l.dataView = new DataView(l.buffer, 0, x)), i = Math.min(i, t.length), t.copy ? t.copy(l, 0, s, i) : l.set(t.slice(s, i)), e -= s, s = 0, I = l.length - 10, t = l;
+    }, X = (i, x, l) => {
+      let n = r.nextId;
+      n || (n = 64), n < L && this.shouldShareStructure && !this.shouldShareStructure(x) ? (n = r.nextOwnId, n < K || (n = L), r.nextOwnId = n + 1) : (n >= K && (n = L), r.nextId = n + 1);
+      let f = x.highByte = n >= 96 && F ? n - 96 >> 5 : -1;
+      i[A] = n, i.__keys__ = x, r[n - 64] = x, n < L ? (x.isShared = !0, r.sharedLength = n - 63, h = !0, f >= 0 ? (t[e++] = (n & 31) + 96, t[e++] = f) : t[e++] = n) : (f >= 0 ? (t[e++] = 213, t[e++] = 114, t[e++] = (n & 31) + 96, t[e++] = f) : (t[e++] = 212, t[e++] = 114, t[e++] = n), l && (q += _ * l), T.length >= P && (T.shift()[A] = 0), T.push(i), b(x));
+    }, v = (i, x, l, n) => {
+      let f = t, u = e, d = I, a = s;
+      t = M, e = 0, s = 0, t || (M = t = new D(8192)), I = t.length - 10, X(i, x, n), M = t;
+      let y = e;
+      if (t = f, e = u, I = d, s = a, y > 1) {
+        let p = e + y - 1;
+        p > I && U(p);
+        let B = l + s;
+        t.copyWithin(B + y, B + 1, e), t.set(M.slice(0, y), B), e = p;
+      } else
+        t[l + s] = M[0];
+    }, fe = (i) => {
+      let x = he(i, t, s, e, r, U, (l, n, f) => {
+        if (f)
+          return h = !0;
+        e = n;
+        let u = t;
+        return b(l), H(), u !== t ? { position: e, targetView: m, target: t } : e;
+      }, this);
+      if (x === 0)
+        return N(i);
+      e = x;
+    };
+  }
+  useBuffer(o) {
+    t = o, t.dataView || (t.dataView = new DataView(t.buffer, t.byteOffset, t.byteLength)), m = t.dataView, e = 0;
+  }
+  set position(o) {
+    e = o;
+  }
+  get position() {
+    return e;
+  }
+  clearSharedData() {
+    this.structures && (this.structures = []), this.typedStructs && (this.typedStructs = []);
+  }
+}
+se = [Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor, DataView, xe];
+j = [{
+  pack(c, o, s) {
+    let h = c.getTime() / 1e3;
+    if ((this.useTimestamp32 || c.getMilliseconds() === 0) && h >= 0 && h < 4294967296) {
+      let { target: r, targetView: g, position: w } = o(6);
+      r[w++] = 214, r[w++] = 255, g.setUint32(w, h);
+    } else if (h > 0 && h < 4294967296) {
+      let { target: r, targetView: g, position: w } = o(10);
+      r[w++] = 215, r[w++] = 255, g.setUint32(w, c.getMilliseconds() * 4e6 + (h / 1e3 / 4294967296 >> 0)), g.setUint32(w + 4, h);
+    } else if (isNaN(h)) {
+      if (this.onInvalidDate)
+        return o(0), s(this.onInvalidDate());
+      let { target: r, targetView: g, position: w } = o(3);
+      r[w++] = 212, r[w++] = 255, r[w++] = 255;
+    } else {
+      let { target: r, targetView: g, position: w } = o(15);
+      r[w++] = 199, r[w++] = 12, r[w++] = 255, g.setUint32(w, c.getMilliseconds() * 1e6), g.setBigInt64(w + 4, BigInt(Math.floor(h)));
+    }
+  }
+}, {
+  pack(c, o, s) {
+    if (this.setAsEmptyObject)
+      return o(0), s({});
+    let h = Array.from(c), { target: r, position: g } = o(this.moreTypes ? 3 : 0);
+    this.moreTypes && (r[g++] = 212, r[g++] = 115, r[g++] = 0), s(h);
+  }
+}, {
+  pack(c, o, s) {
+    let { target: h, position: r } = o(this.moreTypes ? 3 : 0);
+    this.moreTypes && (h[r++] = 212, h[r++] = 101, h[r++] = 0), s([c.name, c.message, c.cause]);
+  }
+}, {
+  pack(c, o, s) {
+    let { target: h, position: r } = o(this.moreTypes ? 3 : 0);
+    this.moreTypes && (h[r++] = 212, h[r++] = 120, h[r++] = 0), s([c.source, c.flags]);
+  }
+}, {
+  pack(c, o) {
+    this.moreTypes ? Z(c, 16, o) : Y(R ? Buffer.from(c) : new Uint8Array(c), o);
+  }
+}, {
+  pack(c, o) {
+    let s = c.constructor;
+    s !== re && this.moreTypes ? Z(c, ce.indexOf(s.name), o) : Y(c, o);
+  }
+}, {
+  pack(c, o) {
+    this.moreTypes ? Z(c, 17, o) : Y(R ? Buffer.from(c) : new Uint8Array(c), o);
+  }
+}, {
+  pack(c, o) {
+    let { target: s, position: h } = o(1);
+    s[h] = 193;
+  }
+}];
+function Z(c, o, s, h) {
+  let r = c.byteLength;
+  if (r + 1 < 256) {
+    var { target: g, position: w } = s(4 + r);
+    g[w++] = 199, g[w++] = r + 1;
+  } else if (r + 1 < 65536) {
+    var { target: g, position: w } = s(5 + r);
+    g[w++] = 200, g[w++] = r + 1 >> 8, g[w++] = r + 1 & 255;
+  } else {
+    var { target: g, position: w, targetView: k } = s(7 + r);
+    g[w++] = 201, k.setUint32(w, r + 1), w += 4;
+  }
+  g[w++] = 116, g[w++] = o, c.buffer || (c = new Uint8Array(c)), g.set(new Uint8Array(c.buffer, c.byteOffset, c.byteLength), w);
+}
+function Y(c, o) {
+  let s = c.byteLength;
+  var h, r;
+  if (s < 256) {
+    var { target: h, position: r } = o(s + 2);
+    h[r++] = 196, h[r++] = s;
+  } else if (s < 65536) {
+    var { target: h, position: r } = o(s + 3);
+    h[r++] = 197, h[r++] = s >> 8, h[r++] = s & 255;
+  } else {
+    var { target: h, position: r, targetView: g } = o(s + 5);
+    h[r++] = 198, g.setUint32(r, s), r += 4;
+  }
+  h.set(c, r);
+}
+function te(c, o, s, h) {
+  let r = c.length;
+  switch (r) {
+    case 1:
+      o[s++] = 212;
+      break;
+    case 2:
+      o[s++] = 213;
+      break;
+    case 4:
+      o[s++] = 214;
+      break;
+    case 8:
+      o[s++] = 215;
+      break;
+    case 16:
+      o[s++] = 216;
+      break;
+    default:
+      r < 256 ? (o[s++] = 199, o[s++] = r) : r < 65536 ? (o[s++] = 200, o[s++] = r >> 8, o[s++] = r & 255) : (o[s++] = 201, o[s++] = r >> 24, o[s++] = r >> 16 & 255, o[s++] = r >> 8 & 255, o[s++] = r & 255);
+  }
+  return o[s++] = h, o.set(c, s), s += r, s;
+}
+function ge(c, o) {
+  let s, h = o.length * 6, r = c.length - h;
+  for (; s = o.pop(); ) {
+    let g = s.offset, w = s.id;
+    c.copyWithin(g + h, g, r), h -= 6;
+    let k = g + h;
+    c[k++] = 214, c[k++] = 105, c[k++] = w >> 24, c[k++] = w >> 16 & 255, c[k++] = w >> 8 & 255, c[k++] = w & 255, r = g;
+  }
+  return c;
+}
+function ie(c, o, s) {
+  if (S.length > 0) {
+    m.setUint32(S.position + c, e + s - S.position - c), S.stringsPosition = e - c;
+    let h = S;
+    S = null, o(h[0]), o(h[1]);
+  }
+}
+function we(c, o) {
+  return c.isCompatible = (s) => {
+    let h = !s || (o.lastNamedStructuresLength || 0) === s.length;
+    return h || o._mergeStructures(s), h;
+  }, c;
+}
+let ne = new de({ useRecords: !1 });
+const ke = ne.pack;
+ne.pack;
+const ye = 512, pe = 1024, me = 2048;
+export {
+  de as Packr,
+  A as RECORD_SYMBOL,
+  me as RESERVE_START_SPACE,
+  pe as RESET_BUFFER_MODE,
+  ye as REUSE_BUFFER_MODE,
+  ke as pack
+};