web-core-tcm 0.0.25 → 0.0.26

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js

@@ -0,0 +1,42 @@
+function o(e) {
+  let s = !1;
+  const c = [];
+  for (let a = 0; a < e.length; a++) {
+    let t = e.charAt(a);
+    switch (t) {
+      case "_":
+        s = !0;
+        break;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        c.push(t), s = !1;
+        break;
+      default:
+        s && (s = !1, t = t.toUpperCase()), c.push(t);
+        break;
+    }
+  }
+  return c.join("");
+}
+const r = /* @__PURE__ */ new Set([
+  // names reserved by JavaScript
+  "constructor",
+  "toString",
+  "toJSON",
+  "valueOf"
+]);
+function f(e) {
+  return r.has(e) ? e + "$" : e;
+}
+export {
+  o as protoCamelCase,
+  f as safeObjectProperty
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js

@@ -0,0 +1,17 @@
+function* i(e) {
+  switch (e.kind) {
+    case "file":
+      for (const s of e.messages)
+        yield s, yield* i(s);
+      yield* e.enums, yield* e.services, yield* e.extensions;
+      break;
+    case "message":
+      for (const s of e.nestedMessages)
+        yield s, yield* i(s);
+      yield* e.nestedEnums, yield* e.nestedExtensions;
+      break;
+  }
+}
+export {
+  i as nestedTypes
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js

@@ -0,0 +1,156 @@
+import { ScalarType as r } from "../descriptors.js";
+import { isMessage as N } from "../is-message.js";
+import { FieldError as s } from "./error.js";
+import { isReflectList as m, isReflectMap as p, isReflectMessage as g } from "./guard.js";
+import { UINT32_MAX as T, INT32_MAX as S, INT32_MIN as h, FLOAT32_MAX as F, FLOAT32_MIN as E } from "../wire/binary-encoding.js";
+import { getTextEncoding as M } from "../wire/text-encoding.js";
+import { protoInt64 as f } from "../proto-int64.js";
+function w(e, t) {
+  const n = e.fieldKind == "list" ? m(t, e) : e.fieldKind == "map" ? p(t, e) : u(e, t);
+  if (n === !0)
+    return;
+  let c;
+  switch (e.fieldKind) {
+    case "list":
+      c = `expected ${I(e)}, got ${o(t)}`;
+      break;
+    case "map":
+      c = `expected ${b(e)}, got ${o(t)}`;
+      break;
+    default:
+      c = i(e, t, n);
+  }
+  return new s(e, c);
+}
+function x(e, t, n) {
+  const c = u(e, n);
+  if (c !== !0)
+    return new s(e, `list item #${t + 1}: ${i(e, n, c)}`);
+}
+function O(e, t, n) {
+  const c = y(t, e.mapKey);
+  if (c !== !0)
+    return new s(e, `invalid map key: ${i({ scalar: e.mapKey }, t, c)}`);
+  const a = u(e, n);
+  if (a !== !0)
+    return new s(e, `map entry ${o(t)}: ${i(e, n, a)}`);
+}
+function u(e, t) {
+  return e.scalar !== void 0 ? y(t, e.scalar) : e.enum !== void 0 ? e.enum.open ? Number.isInteger(t) : e.enum.values.some((n) => n.number === t) : g(t, e.message);
+}
+function y(e, t) {
+  switch (t) {
+    case r.DOUBLE:
+      return typeof e == "number";
+    case r.FLOAT:
+      return typeof e != "number" ? !1 : Number.isNaN(e) || !Number.isFinite(e) ? !0 : e > F || e < E ? `${e.toFixed()} out of range` : !0;
+    case r.INT32:
+    case r.SFIXED32:
+    case r.SINT32:
+      return typeof e != "number" || !Number.isInteger(e) ? !1 : e > S || e < h ? `${e.toFixed()} out of range` : !0;
+    case r.FIXED32:
+    case r.UINT32:
+      return typeof e != "number" || !Number.isInteger(e) ? !1 : e > T || e < 0 ? `${e.toFixed()} out of range` : !0;
+    case r.BOOL:
+      return typeof e == "boolean";
+    case r.STRING:
+      return typeof e != "string" ? !1 : M().checkUtf8(e) || "invalid UTF8";
+    case r.BYTES:
+      return e instanceof Uint8Array;
+    case r.INT64:
+    case r.SFIXED64:
+    case r.SINT64:
+      if (typeof e == "bigint" || typeof e == "number" || typeof e == "string" && e.length > 0)
+        try {
+          return f.parse(e), !0;
+        } catch {
+          return `${e} out of range`;
+        }
+      return !1;
+    case r.FIXED64:
+    case r.UINT64:
+      if (typeof e == "bigint" || typeof e == "number" || typeof e == "string" && e.length > 0)
+        try {
+          return f.uParse(e), !0;
+        } catch {
+          return `${e} out of range`;
+        }
+      return !1;
+  }
+}
+function i(e, t, n) {
+  return n = typeof n == "string" ? `: ${n}` : `, got ${o(t)}`, e.scalar !== void 0 ? `expected ${R(e.scalar)}` + n : e.enum !== void 0 ? `expected ${e.enum.toString()}` + n : `expected ${$(e.message)}` + n;
+}
+function o(e) {
+  switch (typeof e) {
+    case "object":
+      return e === null ? "null" : e instanceof Uint8Array ? `Uint8Array(${e.length})` : Array.isArray(e) ? `Array(${e.length})` : m(e) ? I(e.field()) : p(e) ? b(e.field()) : g(e) ? $(e.desc) : N(e) ? `message ${e.$typeName}` : "object";
+    case "string":
+      return e.length > 30 ? "string" : `"${e.split('"').join('\\"')}"`;
+    case "boolean":
+      return String(e);
+    case "number":
+      return String(e);
+    case "bigint":
+      return String(e) + "n";
+    default:
+      return typeof e;
+  }
+}
+function $(e) {
+  return `ReflectMessage (${e.typeName})`;
+}
+function I(e) {
+  switch (e.listKind) {
+    case "message":
+      return `ReflectList (${e.message.toString()})`;
+    case "enum":
+      return `ReflectList (${e.enum.toString()})`;
+    case "scalar":
+      return `ReflectList (${r[e.scalar]})`;
+  }
+}
+function b(e) {
+  switch (e.mapKind) {
+    case "message":
+      return `ReflectMap (${r[e.mapKey]}, ${e.message.toString()})`;
+    case "enum":
+      return `ReflectMap (${r[e.mapKey]}, ${e.enum.toString()})`;
+    case "scalar":
+      return `ReflectMap (${r[e.mapKey]}, ${r[e.scalar]})`;
+  }
+}
+function R(e) {
+  switch (e) {
+    case r.STRING:
+      return "string";
+    case r.BOOL:
+      return "boolean";
+    case r.INT64:
+    case r.SINT64:
+    case r.SFIXED64:
+      return "bigint (int64)";
+    case r.UINT64:
+    case r.FIXED64:
+      return "bigint (uint64)";
+    case r.BYTES:
+      return "Uint8Array";
+    case r.DOUBLE:
+      return "number (float64)";
+    case r.FLOAT:
+      return "number (float32)";
+    case r.FIXED32:
+    case r.UINT32:
+      return "number (uint32)";
+    case r.INT32:
+    case r.SFIXED32:
+    case r.SINT32:
+      return "number (int32)";
+  }
+}
+export {
+  w as checkField,
+  x as checkListItem,
+  O as checkMapEntry,
+  o as formatVal
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js

@@ -0,0 +1,349 @@
+import { ScalarType as i } from "../descriptors.js";
+import { checkField as j, checkMapEntry as O, checkListItem as b } from "./reflect-check.js";
+import { FieldError as _ } from "./error.js";
+import { unsafeLocal as o, unsafeOneofCase as F, unsafeIsSet as R, unsafeClear as E, unsafeGet as K, unsafeSet as L } from "./unsafe.js";
+import { create as A } from "../create.js";
+import { isWrapperDesc as $, isWrapper as M } from "../wkt/wrappers.js";
+import { scalarZeroValue as X } from "./scalar.js";
+import { protoInt64 as a } from "../proto-int64.js";
+import { isReflectMap as U, isReflectList as P, isObject as w, isReflectMessage as B } from "./guard.js";
+function v(t, e, s = !0) {
+  return new S(t, e, s);
+}
+const d = /* @__PURE__ */ new WeakMap();
+class S {
+  get sortedFields() {
+    const e = d.get(this.desc);
+    if (e)
+      return e;
+    const s = this.desc.fields.concat().sort((r, n) => r.number - n.number);
+    return d.set(this.desc, s), s;
+  }
+  constructor(e, s, r = !0) {
+    this.lists = /* @__PURE__ */ new Map(), this.maps = /* @__PURE__ */ new Map(), this.check = r, this.desc = e, this.message = this[o] = s ?? A(e), this.fields = e.fields, this.oneofs = e.oneofs, this.members = e.members;
+  }
+  findNumber(e) {
+    return this._fieldsByNumber || (this._fieldsByNumber = new Map(this.desc.fields.map((s) => [s.number, s]))), this._fieldsByNumber.get(e);
+  }
+  oneofCase(e) {
+    return c(this.message, e), F(this.message, e);
+  }
+  isSet(e) {
+    return c(this.message, e), R(this.message, e);
+  }
+  clear(e) {
+    c(this.message, e), E(this.message, e);
+  }
+  get(e) {
+    c(this.message, e);
+    const s = K(this.message, e);
+    switch (e.fieldKind) {
+      case "list":
+        let r = this.lists.get(e);
+        return (!r || r[o] !== s) && this.lists.set(
+          e,
+          // biome-ignore lint/suspicious/noAssignInExpressions: no
+          r = new D(e, s, this.check)
+        ), r;
+      case "map":
+        let n = this.maps.get(e);
+        return (!n || n[o] !== s) && this.maps.set(
+          e,
+          // biome-ignore lint/suspicious/noAssignInExpressions: no
+          n = new C(e, s, this.check)
+        ), n;
+      case "message":
+        return m(e, s, this.check);
+      case "scalar":
+        return s === void 0 ? X(e.scalar, !1) : g(e, s);
+      case "enum":
+        return s ?? e.enum.values[0].number;
+    }
+  }
+  set(e, s) {
+    if (c(this.message, e), this.check) {
+      const n = j(e, s);
+      if (n)
+        throw n;
+    }
+    let r;
+    e.fieldKind == "message" ? r = l(e, s) : U(s) || P(s) ? r = s[o] : r = p(e, s), L(this.message, e, r);
+  }
+  getUnknown() {
+    return this.message.$unknown;
+  }
+  setUnknown(e) {
+    this.message.$unknown = e;
+  }
+}
+function c(t, e) {
+  if (e.parent.typeName !== t.$typeName)
+    throw new _(e, `cannot use ${e.toString()} with message ${t.$typeName}`, "ForeignFieldError");
+}
+class D {
+  field() {
+    return this._field;
+  }
+  get size() {
+    return this._arr.length;
+  }
+  constructor(e, s, r) {
+    this._field = e, this._arr = this[o] = s, this.check = r;
+  }
+  get(e) {
+    const s = this._arr[e];
+    return s === void 0 ? void 0 : u(this._field, s, this.check);
+  }
+  set(e, s) {
+    if (e < 0 || e >= this._arr.length)
+      throw new _(this._field, `list item #${e + 1}: out of range`);
+    if (this.check) {
+      const r = b(this._field, e, s);
+      if (r)
+        throw r;
+    }
+    this._arr[e] = k(this._field, s);
+  }
+  add(e) {
+    if (this.check) {
+      const s = b(this._field, this._arr.length, e);
+      if (s)
+        throw s;
+    }
+    this._arr.push(k(this._field, e));
+  }
+  clear() {
+    this._arr.splice(0, this._arr.length);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  keys() {
+    return this._arr.keys();
+  }
+  *values() {
+    for (const e of this._arr)
+      yield u(this._field, e, this.check);
+  }
+  *entries() {
+    for (let e = 0; e < this._arr.length; e++)
+      yield [e, u(this._field, this._arr[e], this.check)];
+  }
+}
+class C {
+  constructor(e, s, r = !0) {
+    this.obj = this[o] = s ?? {}, this.check = r, this._field = e;
+  }
+  field() {
+    return this._field;
+  }
+  set(e, s) {
+    if (this.check) {
+      const r = O(this._field, e, s);
+      if (r)
+        throw r;
+    }
+    return this.obj[h(e)] = W(this._field, s), this;
+  }
+  delete(e) {
+    const s = h(e), r = Object.prototype.hasOwnProperty.call(this.obj, s);
+    return r && delete this.obj[s], r;
+  }
+  clear() {
+    for (const e of Object.keys(this.obj))
+      delete this.obj[e];
+  }
+  get(e) {
+    let s = this.obj[h(e)];
+    return s !== void 0 && (s = f(this._field, s, this.check)), s;
+  }
+  has(e) {
+    return Object.prototype.hasOwnProperty.call(this.obj, h(e));
+  }
+  *keys() {
+    for (const e of Object.keys(this.obj))
+      yield y(e, this._field.mapKey);
+  }
+  *entries() {
+    for (const e of Object.entries(this.obj))
+      yield [
+        y(e[0], this._field.mapKey),
+        f(this._field, e[1], this.check)
+      ];
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return Object.keys(this.obj).length;
+  }
+  *values() {
+    for (const e of Object.values(this.obj))
+      yield f(this._field, e, this.check);
+  }
+  forEach(e, s) {
+    for (const r of this.entries())
+      e.call(s, r[1], r[0], this);
+  }
+}
+function l(t, e) {
+  return B(e) ? M(e.message) && !t.oneof && t.fieldKind == "message" ? e.message.value : e.desc.typeName == "google.protobuf.Struct" && t.parent.typeName != "google.protobuf.Value" ? T(e.message) : e.message : e;
+}
+function m(t, e, s) {
+  return e !== void 0 && ($(t.message) && !t.oneof && t.fieldKind == "message" ? e = {
+    $typeName: t.message.typeName,
+    value: g(t.message.fields[0], e)
+  } : t.message.typeName == "google.protobuf.Struct" && t.parent.typeName != "google.protobuf.Value" && w(e) && (e = N(e))), new S(t.message, e, s);
+}
+function k(t, e) {
+  return t.listKind == "message" ? l(t, e) : p(t, e);
+}
+function u(t, e, s) {
+  return t.listKind == "message" ? m(t, e, s) : g(t, e);
+}
+function W(t, e) {
+  return t.mapKind == "message" ? l(t, e) : p(t, e);
+}
+function f(t, e, s) {
+  return t.mapKind == "message" ? m(t, e, s) : e;
+}
+function h(t) {
+  return typeof t == "string" || typeof t == "number" ? t : String(t);
+}
+function y(t, e) {
+  switch (e) {
+    case i.STRING:
+      return t;
+    case i.INT32:
+    case i.FIXED32:
+    case i.UINT32:
+    case i.SFIXED32:
+    case i.SINT32: {
+      const s = Number.parseInt(t);
+      if (Number.isFinite(s))
+        return s;
+      break;
+    }
+    case i.BOOL:
+      switch (t) {
+        case "true":
+          return !0;
+        case "false":
+          return !1;
+      }
+      break;
+    case i.UINT64:
+    case i.FIXED64:
+      try {
+        return a.uParse(t);
+      } catch {
+      }
+      break;
+    default:
+      try {
+        return a.parse(t);
+      } catch {
+      }
+      break;
+  }
+  return t;
+}
+function g(t, e) {
+  switch (t.scalar) {
+    case i.INT64:
+    case i.SFIXED64:
+    case i.SINT64:
+      "longAsString" in t && t.longAsString && typeof e == "string" && (e = a.parse(e));
+      break;
+    case i.FIXED64:
+    case i.UINT64:
+      "longAsString" in t && t.longAsString && typeof e == "string" && (e = a.uParse(e));
+      break;
+  }
+  return e;
+}
+function p(t, e) {
+  switch (t.scalar) {
+    case i.INT64:
+    case i.SFIXED64:
+    case i.SINT64:
+      "longAsString" in t && t.longAsString ? e = String(e) : (typeof e == "string" || typeof e == "number") && (e = a.parse(e));
+      break;
+    case i.FIXED64:
+    case i.UINT64:
+      "longAsString" in t && t.longAsString ? e = String(e) : (typeof e == "string" || typeof e == "number") && (e = a.uParse(e));
+      break;
+  }
+  return e;
+}
+function N(t) {
+  const e = {
+    $typeName: "google.protobuf.Struct",
+    fields: {}
+  };
+  if (w(t))
+    for (const [s, r] of Object.entries(t))
+      e.fields[s] = V(r);
+  return e;
+}
+function T(t) {
+  const e = {};
+  for (const [s, r] of Object.entries(t.fields))
+    e[s] = I(r);
+  return e;
+}
+function I(t) {
+  switch (t.kind.case) {
+    case "structValue":
+      return T(t.kind.value);
+    case "listValue":
+      return t.kind.value.values.map(I);
+    case "nullValue":
+    case void 0:
+      return null;
+    default:
+      return t.kind.value;
+  }
+}
+function V(t) {
+  const e = {
+    $typeName: "google.protobuf.Value",
+    kind: { case: void 0 }
+  };
+  switch (typeof t) {
+    case "number":
+      e.kind = { case: "numberValue", value: t };
+      break;
+    case "string":
+      e.kind = { case: "stringValue", value: t };
+      break;
+    case "boolean":
+      e.kind = { case: "boolValue", value: t };
+      break;
+    case "object":
+      if (t === null)
+        e.kind = { case: "nullValue", value: 0 };
+      else if (Array.isArray(t)) {
+        const s = {
+          $typeName: "google.protobuf.ListValue",
+          values: []
+        };
+        if (Array.isArray(t))
+          for (const r of t)
+            s.values.push(V(r));
+        e.kind = {
+          case: "listValue",
+          value: s
+        };
+      } else
+        e.kind = {
+          case: "structValue",
+          value: N(t)
+        };
+      break;
+  }
+  return e;
+}
+export {
+  v as reflect
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js

@@ -0,0 +1,39 @@
+import { protoInt64 as a } from "../proto-int64.js";
+import { ScalarType as r } from "../descriptors.js";
+function s(t, e) {
+  switch (t) {
+    case r.STRING:
+      return "";
+    case r.BOOL:
+      return !1;
+    case r.DOUBLE:
+    case r.FLOAT:
+      return 0;
+    case r.INT64:
+    case r.UINT64:
+    case r.SFIXED64:
+    case r.FIXED64:
+    case r.SINT64:
+      return e ? "0" : a.zero;
+    case r.BYTES:
+      return new Uint8Array(0);
+    default:
+      return 0;
+  }
+}
+function o(t, e) {
+  switch (t) {
+    case r.BOOL:
+      return e === !1;
+    case r.STRING:
+      return e === "";
+    case r.BYTES:
+      return e instanceof Uint8Array && !e.byteLength;
+    default:
+      return e == 0;
+  }
+}
+export {
+  o as isScalarZeroValue,
+  s as scalarZeroValue
+};

package/dist/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js

@@ -0,0 +1,72 @@
+import { isScalarZeroValue as s, scalarZeroValue as r } from "./scalar.js";
+const c = 2, l = Symbol.for("reflect unsafe local");
+function f(n, e) {
+  const a = n[e.localName].case;
+  return a === void 0 ? a : e.fields.find((o) => o.localName === a);
+}
+function m(n, e) {
+  const a = e.localName;
+  if (e.oneof)
+    return n[e.oneof.localName].case === a;
+  if (e.presence != c)
+    return n[a] !== void 0 && Object.prototype.hasOwnProperty.call(n, a);
+  switch (e.fieldKind) {
+    case "list":
+      return n[a].length > 0;
+    case "map":
+      return Object.keys(n[a]).length > 0;
+    case "scalar":
+      return !s(e.scalar, n[a]);
+    case "enum":
+      return n[a] !== e.enum.values[0].number;
+  }
+  throw new Error("message field with implicit presence");
+}
+function t(n, e) {
+  return Object.prototype.hasOwnProperty.call(n, e) && n[e] !== void 0;
+}
+function i(n, e) {
+  if (e.oneof) {
+    const a = n[e.oneof.localName];
+    return a.case === e.localName ? a.value : void 0;
+  }
+  return n[e.localName];
+}
+function p(n, e, a) {
+  e.oneof ? n[e.oneof.localName] = {
+    case: e.localName,
+    value: a
+  } : n[e.localName] = a;
+}
+function N(n, e) {
+  const a = e.localName;
+  if (e.oneof) {
+    const o = e.oneof.localName;
+    n[o].case === a && (n[o] = { case: void 0 });
+  } else if (e.presence != c)
+    delete n[a];
+  else
+    switch (e.fieldKind) {
+      case "map":
+        n[a] = {};
+        break;
+      case "list":
+        n[a] = [];
+        break;
+      case "enum":
+        n[a] = e.enum.values[0].number;
+        break;
+      case "scalar":
+        n[a] = r(e.scalar, e.longAsString);
+        break;
+    }
+}
+export {
+  N as unsafeClear,
+  i as unsafeGet,
+  m as unsafeIsSet,
+  t as unsafeIsSetExplicit,
+  l as unsafeLocal,
+  f as unsafeOneofCase,
+  p as unsafeSet
+};