web-core-tcm 0.0.24 → 0.0.26

package/dist/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js

@@ -0,0 +1,58 @@
+function g(e) {
+  const c = h();
+  let s = e.length * 3 / 4;
+  e[e.length - 2] == "=" ? s -= 2 : e[e.length - 1] == "=" && (s -= 1);
+  let a = new Uint8Array(s), r = 0, t = 0, n, o = 0;
+  for (let l = 0; l < e.length; l++) {
+    if (n = c[e.charCodeAt(l)], n === void 0)
+      switch (e[l]) {
+        // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+        case "=":
+          t = 0;
+        // reset state when padding found
+        case `
+`:
+        case "\r":
+        case "	":
+        case " ":
+          continue;
+        // skip white-space, and padding
+        default:
+          throw Error("invalid base64 string");
+      }
+    switch (t) {
+      case 0:
+        o = n, t = 1;
+        break;
+      case 1:
+        a[r++] = o << 2 | (n & 48) >> 4, o = n, t = 2;
+        break;
+      case 2:
+        a[r++] = (o & 15) << 4 | (n & 60) >> 2, o = n, t = 3;
+        break;
+      case 3:
+        a[r++] = (o & 3) << 6 | n, t = 0;
+        break;
+    }
+  }
+  if (t == 1)
+    throw Error("invalid base64 string");
+  return a.subarray(0, r);
+}
+let d, i;
+function f(e) {
+  return d || (d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""), d.slice(0, -2).concat("-", "_")), d;
+}
+function h() {
+  if (!i) {
+    i = [];
+    const e = f();
+    for (let c = 0; c < e.length; c++)
+      i[e[c].charCodeAt(0)] = c;
+    i[45] = e.indexOf("+"), i[95] = e.indexOf("/");
+  }
+  return i;
+}
+export {
+  g as base64Decode
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js

@@ -0,0 +1,350 @@
+import { varint32write as c, varint64write as o, varint64read as b, varint32read as d } from "./varint.js";
+import { protoInt64 as r } from "../proto-int64.js";
+import { getTextEncoding as l } from "./text-encoding.js";
+var h;
+(function(e) {
+  e[e.Varint = 0] = "Varint", e[e.Bit64 = 1] = "Bit64", e[e.LengthDelimited = 2] = "LengthDelimited", e[e.StartGroup = 3] = "StartGroup", e[e.EndGroup = 4] = "EndGroup", e[e.Bit32 = 5] = "Bit32";
+})(h || (h = {}));
+const p = 34028234663852886e22, k = -34028234663852886e22, y = 4294967295, m = 2147483647, x = -2147483648;
+class A {
+  constructor(t = l().encodeUtf8) {
+    this.encodeUtf8 = t, this.stack = [], this.chunks = [], this.buf = [];
+  }
+  /**
+   * Return all bytes written and reset this writer.
+   */
+  finish() {
+    this.buf.length && (this.chunks.push(new Uint8Array(this.buf)), this.buf = []);
+    let t = 0;
+    for (let n = 0; n < this.chunks.length; n++)
+      t += this.chunks[n].length;
+    let i = new Uint8Array(t), s = 0;
+    for (let n = 0; n < this.chunks.length; n++)
+      i.set(this.chunks[n], s), s += this.chunks[n].length;
+    return this.chunks = [], i;
+  }
+  /**
+   * Start a new fork for length-delimited data like a message
+   * or a packed repeated field.
+   *
+   * Must be joined later with `join()`.
+   */
+  fork() {
+    return this.stack.push({ chunks: this.chunks, buf: this.buf }), this.chunks = [], this.buf = [], this;
+  }
+  /**
+   * Join the last fork. Write its length and bytes, then
+   * return to the previous state.
+   */
+  join() {
+    let t = this.finish(), i = this.stack.pop();
+    if (!i)
+      throw new Error("invalid state, fork stack empty");
+    return this.chunks = i.chunks, this.buf = i.buf, this.uint32(t.byteLength), this.raw(t);
+  }
+  /**
+   * Writes a tag (field number and wire type).
+   *
+   * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+   *
+   * Generated code should compute the tag ahead of time and call `uint32()`.
+   */
+  tag(t, i) {
+    return this.uint32((t << 3 | i) >>> 0);
+  }
+  /**
+   * Write a chunk of raw bytes.
+   */
+  raw(t) {
+    return this.buf.length && (this.chunks.push(new Uint8Array(this.buf)), this.buf = []), this.chunks.push(t), this;
+  }
+  /**
+   * Write a `uint32` value, an unsigned 32 bit varint.
+   */
+  uint32(t) {
+    for (w(t); t > 127; )
+      this.buf.push(t & 127 | 128), t = t >>> 7;
+    return this.buf.push(t), this;
+  }
+  /**
+   * Write a `int32` value, a signed 32 bit varint.
+   */
+  int32(t) {
+    return f(t), c(t, this.buf), this;
+  }
+  /**
+   * Write a `bool` value, a variant.
+   */
+  bool(t) {
+    return this.buf.push(t ? 1 : 0), this;
+  }
+  /**
+   * Write a `bytes` value, length-delimited arbitrary data.
+   */
+  bytes(t) {
+    return this.uint32(t.byteLength), this.raw(t);
+  }
+  /**
+   * Write a `string` value, length-delimited data converted to UTF-8 text.
+   */
+  string(t) {
+    let i = this.encodeUtf8(t);
+    return this.uint32(i.byteLength), this.raw(i);
+  }
+  /**
+   * Write a `float` value, 32-bit floating point number.
+   */
+  float(t) {
+    E(t);
+    let i = new Uint8Array(4);
+    return new DataView(i.buffer).setFloat32(0, t, !0), this.raw(i);
+  }
+  /**
+   * Write a `double` value, a 64-bit floating point number.
+   */
+  double(t) {
+    let i = new Uint8Array(8);
+    return new DataView(i.buffer).setFloat64(0, t, !0), this.raw(i);
+  }
+  /**
+   * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32(t) {
+    w(t);
+    let i = new Uint8Array(4);
+    return new DataView(i.buffer).setUint32(0, t, !0), this.raw(i);
+  }
+  /**
+   * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32(t) {
+    f(t);
+    let i = new Uint8Array(4);
+    return new DataView(i.buffer).setInt32(0, t, !0), this.raw(i);
+  }
+  /**
+   * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32(t) {
+    return f(t), t = (t << 1 ^ t >> 31) >>> 0, c(t, this.buf), this;
+  }
+  /**
+   * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64(t) {
+    let i = new Uint8Array(8), s = new DataView(i.buffer), n = r.enc(t);
+    return s.setInt32(0, n.lo, !0), s.setInt32(4, n.hi, !0), this.raw(i);
+  }
+  /**
+   * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64(t) {
+    let i = new Uint8Array(8), s = new DataView(i.buffer), n = r.uEnc(t);
+    return s.setInt32(0, n.lo, !0), s.setInt32(4, n.hi, !0), this.raw(i);
+  }
+  /**
+   * Write a `int64` value, a signed 64-bit varint.
+   */
+  int64(t) {
+    let i = r.enc(t);
+    return o(i.lo, i.hi, this.buf), this;
+  }
+  /**
+   * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64(t) {
+    const i = r.enc(t), s = i.hi >> 31, n = i.lo << 1 ^ s, u = (i.hi << 1 | i.lo >>> 31) ^ s;
+    return o(n, u, this.buf), this;
+  }
+  /**
+   * Write a `uint64` value, an unsigned 64-bit varint.
+   */
+  uint64(t) {
+    const i = r.uEnc(t);
+    return o(i.lo, i.hi, this.buf), this;
+  }
+}
+class v {
+  constructor(t, i = l().decodeUtf8) {
+    this.decodeUtf8 = i, this.varint64 = b, this.uint32 = d, this.buf = t, this.len = t.length, this.pos = 0, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let t = this.uint32(), i = t >>> 3, s = t & 7;
+    if (i <= 0 || s < 0 || s > 5)
+      throw new Error("illegal tag: field no " + i + " wire type " + s);
+    return [i, s];
+  }
+  /**
+   * Skip one element and return the skipped data.
+   *
+   * When skipping StartGroup, provide the tags field number to check for
+   * matching field number in the EndGroup tag.
+   */
+  skip(t, i) {
+    let s = this.pos;
+    switch (t) {
+      case h.Varint:
+        for (; this.buf[this.pos++] & 128; )
+          ;
+        break;
+      // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+      case h.Bit64:
+        this.pos += 4;
+      case h.Bit32:
+        this.pos += 4;
+        break;
+      case h.LengthDelimited:
+        let n = this.uint32();
+        this.pos += n;
+        break;
+      case h.StartGroup:
+        for (; ; ) {
+          const [u, a] = this.tag();
+          if (a === h.EndGroup) {
+            if (i !== void 0 && u !== i)
+              throw new Error("invalid end group tag");
+            break;
+          }
+          this.skip(a, u);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + t);
+    }
+    return this.assertBounds(), this.buf.subarray(s, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let t = this.uint32();
+    return t >>> 1 ^ -(t & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return r.dec(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return r.uDec(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [t, i] = this.varint64(), s = -(t & 1);
+    return t = (t >>> 1 | (i & 1) << 31) ^ s, i = i >>> 1 ^ s, r.dec(t, i);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [t, i] = this.varint64();
+    return t !== 0 || i !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return r.uDec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return r.dec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, !0);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, !0);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let t = this.uint32(), i = this.pos;
+    return this.pos += t, this.assertBounds(), this.buf.subarray(i, i + t);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+}
+function f(e) {
+  if (typeof e == "string")
+    e = Number(e);
+  else if (typeof e != "number")
+    throw new Error("invalid int32: " + typeof e);
+  if (!Number.isInteger(e) || e > m || e < x)
+    throw new Error("invalid int32: " + e);
+}
+function w(e) {
+  if (typeof e == "string")
+    e = Number(e);
+  else if (typeof e != "number")
+    throw new Error("invalid uint32: " + typeof e);
+  if (!Number.isInteger(e) || e > y || e < 0)
+    throw new Error("invalid uint32: " + e);
+}
+function E(e) {
+  if (typeof e == "string") {
+    const t = e;
+    if (e = Number(e), Number.isNaN(e) && t !== "NaN")
+      throw new Error("invalid float32: " + t);
+  } else if (typeof e != "number")
+    throw new Error("invalid float32: " + typeof e);
+  if (Number.isFinite(e) && (e > p || e < k))
+    throw new Error("invalid float32: " + e);
+}
+export {
+  v as BinaryReader,
+  A as BinaryWriter,
+  p as FLOAT32_MAX,
+  k as FLOAT32_MIN,
+  m as INT32_MAX,
+  x as INT32_MIN,
+  y as UINT32_MAX,
+  h as WireType
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js

@@ -0,0 +1,25 @@
+const o = Symbol.for("@bufbuild/protobuf/text-encoding");
+function r() {
+  if (globalThis[o] == null) {
+    const t = new globalThis.TextEncoder(), n = new globalThis.TextDecoder();
+    globalThis[o] = {
+      encodeUtf8(e) {
+        return t.encode(e);
+      },
+      decodeUtf8(e) {
+        return n.decode(e);
+      },
+      checkUtf8(e) {
+        try {
+          return encodeURIComponent(e), !0;
+        } catch {
+          return !1;
+        }
+      }
+    };
+  }
+  return globalThis[o];
+}
+export {
+  r as getTextEncoding
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js

@@ -0,0 +1,145 @@
+import { ScalarType as s } from "../descriptors.js";
+import { protoInt64 as f } from "../proto-int64.js";
+function p(u, e) {
+  const t = u.values.find((r) => r.name === e);
+  if (!t)
+    throw new Error(`cannot parse ${u} default value: ${e}`);
+  return t.number;
+}
+function I(u, e) {
+  switch (u) {
+    case s.STRING:
+      return e;
+    case s.BYTES: {
+      const t = o(e);
+      if (t === !1)
+        throw new Error(`cannot parse ${s[u]} default value: ${e}`);
+      return t;
+    }
+    case s.INT64:
+    case s.SFIXED64:
+    case s.SINT64:
+      return f.parse(e);
+    case s.UINT64:
+    case s.FIXED64:
+      return f.uParse(e);
+    case s.DOUBLE:
+    case s.FLOAT:
+      switch (e) {
+        case "inf":
+          return Number.POSITIVE_INFINITY;
+        case "-inf":
+          return Number.NEGATIVE_INFINITY;
+        case "nan":
+          return Number.NaN;
+        default:
+          return parseFloat(e);
+      }
+    case s.BOOL:
+      return e === "true";
+    case s.INT32:
+    case s.UINT32:
+    case s.SINT32:
+    case s.FIXED32:
+    case s.SFIXED32:
+      return parseInt(e, 10);
+  }
+}
+function o(u) {
+  const e = [], t = {
+    tail: u,
+    c: "",
+    next() {
+      return this.tail.length == 0 ? !1 : (this.c = this.tail[0], this.tail = this.tail.substring(1), !0);
+    },
+    take(r) {
+      if (this.tail.length >= r) {
+        const n = this.tail.substring(0, r);
+        return this.tail = this.tail.substring(r), n;
+      }
+      return !1;
+    }
+  };
+  for (; t.next(); )
+    switch (t.c) {
+      case "\\":
+        if (t.next())
+          switch (t.c) {
+            case "\\":
+              e.push(t.c.charCodeAt(0));
+              break;
+            case "b":
+              e.push(8);
+              break;
+            case "f":
+              e.push(12);
+              break;
+            case "n":
+              e.push(10);
+              break;
+            case "r":
+              e.push(13);
+              break;
+            case "t":
+              e.push(9);
+              break;
+            case "v":
+              e.push(11);
+              break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7": {
+              const r = t.c, n = t.take(2);
+              if (n === !1)
+                return !1;
+              const c = parseInt(r + n, 8);
+              if (Number.isNaN(c))
+                return !1;
+              e.push(c);
+              break;
+            }
+            case "x": {
+              const r = t.c, n = t.take(2);
+              if (n === !1)
+                return !1;
+              const c = parseInt(r + n, 16);
+              if (Number.isNaN(c))
+                return !1;
+              e.push(c);
+              break;
+            }
+            case "u": {
+              const r = t.c, n = t.take(4);
+              if (n === !1)
+                return !1;
+              const c = parseInt(r + n, 16);
+              if (Number.isNaN(c))
+                return !1;
+              const a = new Uint8Array(4);
+              new DataView(a.buffer).setInt32(0, c, !0), e.push(a[0], a[1], a[2], a[3]);
+              break;
+            }
+            case "U": {
+              const r = t.c, n = t.take(8);
+              if (n === !1)
+                return !1;
+              const c = f.uEnc(r + n), a = new Uint8Array(8), i = new DataView(a.buffer);
+              i.setInt32(0, c.lo, !0), i.setInt32(4, c.hi, !0), e.push(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
+              break;
+            }
+          }
+        break;
+      default:
+        e.push(t.c.charCodeAt(0));
+    }
+  return new Uint8Array(e);
+}
+export {
+  p as parseTextFormatEnumValue,
+  I as parseTextFormatScalarValue
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js

@@ -0,0 +1,110 @@
+function p() {
+  let t = 0, i = 0;
+  for (let n = 0; n < 28; n += 7) {
+    let f = this.buf[this.pos++];
+    if (t |= (f & 127) << n, (f & 128) == 0)
+      return this.assertBounds(), [t, i];
+  }
+  let s = this.buf[this.pos++];
+  if (t |= (s & 15) << 28, i = (s & 112) >> 4, (s & 128) == 0)
+    return this.assertBounds(), [t, i];
+  for (let n = 3; n <= 31; n += 7) {
+    let f = this.buf[this.pos++];
+    if (i |= (f & 127) << n, (f & 128) == 0)
+      return this.assertBounds(), [t, i];
+  }
+  throw new Error("invalid varint");
+}
+function g(t, i, s) {
+  for (let r = 0; r < 28; r = r + 7) {
+    const e = t >>> r, u = !(!(e >>> 7) && i == 0), o = (u ? e | 128 : e) & 255;
+    if (s.push(o), !u)
+      return;
+  }
+  const n = t >>> 28 & 15 | (i & 7) << 4, f = i >> 3 != 0;
+  if (s.push((f ? n | 128 : n) & 255), !!f) {
+    for (let r = 3; r < 31; r = r + 7) {
+      const e = i >>> r, u = !!(e >>> 7), o = (u ? e | 128 : e) & 255;
+      if (s.push(o), !u)
+        return;
+    }
+    s.push(i >>> 31 & 1);
+  }
+}
+const h = 4294967296;
+function B(t) {
+  const i = t[0] === "-";
+  i && (t = t.slice(1));
+  const s = 1e6;
+  let n = 0, f = 0;
+  function r(e, u) {
+    const o = Number(t.slice(e, u));
+    f *= s, n = n * s + o, n >= h && (f = f + (n / h | 0), n = n % h);
+  }
+  return r(-24, -18), r(-18, -12), r(-12, -6), r(-6), i ? l(n, f) : x(n, f);
+}
+function b(t, i) {
+  let s = x(t, i);
+  const n = s.hi & 2147483648;
+  n && (s = l(s.lo, s.hi));
+  const f = a(s.lo, s.hi);
+  return n ? "-" + f : f;
+}
+function a(t, i) {
+  if ({ lo: t, hi: i } = d(t, i), i <= 2097151)
+    return String(h * i + t);
+  const s = t & 16777215, n = (t >>> 24 | i << 8) & 16777215, f = i >> 16 & 65535;
+  let r = s + n * 6777216 + f * 6710656, e = n + f * 8147497, u = f * 2;
+  const o = 1e7;
+  return r >= o && (e += Math.floor(r / o), r %= o), e >= o && (u += Math.floor(e / o), e %= o), u.toString() + c(e) + c(r);
+}
+function d(t, i) {
+  return { lo: t >>> 0, hi: i >>> 0 };
+}
+function x(t, i) {
+  return { lo: t | 0, hi: i | 0 };
+}
+function l(t, i) {
+  return i = ~i, t ? t = ~t + 1 : i += 1, x(t, i);
+}
+const c = (t) => {
+  const i = String(t);
+  return "0000000".slice(i.length) + i;
+};
+function w(t, i) {
+  if (t >= 0) {
+    for (; t > 127; )
+      i.push(t & 127 | 128), t = t >>> 7;
+    i.push(t);
+  } else {
+    for (let s = 0; s < 9; s++)
+      i.push(t & 127 | 128), t = t >> 7;
+    i.push(1);
+  }
+}
+function m() {
+  let t = this.buf[this.pos++], i = t & 127;
+  if ((t & 128) == 0)
+    return this.assertBounds(), i;
+  if (t = this.buf[this.pos++], i |= (t & 127) << 7, (t & 128) == 0)
+    return this.assertBounds(), i;
+  if (t = this.buf[this.pos++], i |= (t & 127) << 14, (t & 128) == 0)
+    return this.assertBounds(), i;
+  if (t = this.buf[this.pos++], i |= (t & 127) << 21, (t & 128) == 0)
+    return this.assertBounds(), i;
+  t = this.buf[this.pos++], i |= (t & 15) << 28;
+  for (let s = 5; (t & 128) !== 0 && s < 10; s++)
+    t = this.buf[this.pos++];
+  if ((t & 128) != 0)
+    throw new Error("invalid varint");
+  return this.assertBounds(), i >>> 0;
+}
+export {
+  B as int64FromString,
+  b as int64ToString,
+  a as uInt64ToString,
+  m as varint32read,
+  w as varint32write,
+  p as varint64read,
+  g as varint64write
+};