web-core-tcm 0.0.52 → 0.0.54

package/dist/node_modules/@bufbuild/protobuf/dist/esm/from-json.js

@@ -0,0 +1,434 @@
+import { ScalarType as i } from "./descriptors.js";
+import { protoInt64 as k } from "./proto-int64.js";
+import { create as N } from "./create.js";
+import { reflect as g } from "./reflect/reflect.js";
+import { isFieldError as E, FieldError as l } from "./reflect/error.js";
+import { formatVal as u } from "./reflect/reflect-check.js";
+import { scalarZeroValue as x } from "./reflect/scalar.js";
+import { base64Decode as D } from "./wire/base64-encoding.js";
+import "./wkt/index.js";
+import { createExtensionContainer as L, setExtension as K } from "./extensions.js";
+import { isWrapperDesc as M } from "./wkt/wrappers.js";
+import { anyPack as Z } from "./wkt/any.js";
+import { ValueSchema as J, NullValue as _, ListValueSchema as C, StructSchema as W } from "./wkt/gen/google/protobuf/struct_pb.js";
+const $ = {
+  ignoreUnknownFields: !1
+};
+function O(r) {
+  return r ? Object.assign(Object.assign({}, $), r) : $;
+}
+function pe(r, e, t) {
+  return R(r, I(e, r.typeName), t);
+}
+function Ne(r, e, t, n) {
+  return X(r, e, I(t, r.typeName), n);
+}
+function R(r, e, t) {
+  const n = g(r);
+  try {
+    d(n, e, O(t));
+  } catch (a) {
+    throw E(a) ? new Error(`cannot decode ${a.field()} from JSON: ${a.message}`, {
+      cause: a
+    }) : a;
+  }
+  return n.message;
+}
+function X(r, e, t, n) {
+  try {
+    d(g(r, e), t, O(n));
+  } catch (a) {
+    throw E(a) ? new Error(`cannot decode ${a.field()} from JSON: ${a.message}`, {
+      cause: a
+    }) : a;
+  }
+  return e;
+}
+function we(r, e) {
+  const t = w(r, e, !1, !1);
+  if (t === p)
+    throw new Error(`cannot decode ${r} from JSON: ${u(e)}`);
+  return t;
+}
+function ye(r, e) {
+  return r.values.find((t) => t.name === e) !== void 0;
+}
+function d(r, e, t) {
+  var n;
+  if (H(r, e, t))
+    return;
+  if (e == null || Array.isArray(e) || typeof e != "object")
+    throw new Error(`cannot decode ${r.desc} from JSON: ${u(e)}`);
+  const a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  for (const o of r.desc.fields)
+    s.set(o.name, o).set(o.jsonName, o);
+  for (const [o, f] of Object.entries(e)) {
+    const c = s.get(o);
+    if (c) {
+      if (c.oneof) {
+        if (f === null && c.fieldKind == "scalar")
+          continue;
+        const m = a.get(c.oneof);
+        if (m !== void 0)
+          throw new l(c.oneof, `oneof set multiple times by ${m.name} and ${c.name}`);
+        a.set(c.oneof, c);
+      }
+      S(r, c, f, t);
+    } else {
+      let m;
+      if (o.startsWith("[") && o.endsWith("]") && // biome-ignore lint/suspicious/noAssignInExpressions: no
+      (m = (n = t.registry) === null || n === void 0 ? void 0 : n.getExtension(o.substring(1, o.length - 1))) && m.extendee.typeName === r.desc.typeName) {
+        const [T, V, U] = L(m);
+        S(T, V, f, t), K(r.message, m, U());
+      }
+      if (!m && !t.ignoreUnknownFields)
+        throw new Error(`cannot decode ${r.desc} from JSON: key "${o}" is unknown`);
+    }
+  }
+}
+function S(r, e, t, n) {
+  switch (e.fieldKind) {
+    case "scalar":
+      q(r, e, t);
+      break;
+    case "enum":
+      G(r, e, t, n);
+      break;
+    case "message":
+      Y(r, e, t, n);
+      break;
+    case "list":
+      P(r.get(e), t, n);
+      break;
+    case "map":
+      B(r.get(e), t, n);
+      break;
+  }
+}
+function B(r, e, t) {
+  if (e === null)
+    return;
+  const n = r.field();
+  if (typeof e != "object" || Array.isArray(e))
+    throw new l(n, "expected object, got " + u(e));
+  for (const [a, s] of Object.entries(e)) {
+    if (s === null)
+      throw new l(n, "map value must not be null");
+    let o;
+    switch (n.mapKind) {
+      case "message":
+        const c = g(n.message);
+        d(c, s, t), o = c;
+        break;
+      case "enum":
+        if (o = w(n.enum, s, t.ignoreUnknownFields, !0), o === p)
+          return;
+        break;
+      case "scalar":
+        o = b(n, s, !0);
+        break;
+    }
+    const f = z(n.mapKey, a);
+    r.set(f, o);
+  }
+}
+function P(r, e, t) {
+  if (e === null)
+    return;
+  const n = r.field();
+  if (!Array.isArray(e))
+    throw new l(n, "expected Array, got " + u(e));
+  for (const a of e) {
+    if (a === null)
+      throw new l(n, "list item must not be null");
+    switch (n.listKind) {
+      case "message":
+        const s = g(n.message);
+        d(s, a, t), r.add(s);
+        break;
+      case "enum":
+        const o = w(n.enum, a, t.ignoreUnknownFields, !0);
+        o !== p && r.add(o);
+        break;
+      case "scalar":
+        r.add(b(n, a, !0));
+        break;
+    }
+  }
+}
+function Y(r, e, t, n) {
+  if (t === null && e.message.typeName != "google.protobuf.Value") {
+    r.clear(e);
+    return;
+  }
+  const a = r.isSet(e) ? r.get(e) : g(e.message);
+  d(a, t, n), r.set(e, a);
+}
+function G(r, e, t, n) {
+  const a = w(e.enum, t, n.ignoreUnknownFields, !1);
+  a === y ? r.clear(e) : a !== p && r.set(e, a);
+}
+function q(r, e, t) {
+  const n = b(e, t, !1);
+  n === y ? r.clear(e) : r.set(e, n);
+}
+const p = Symbol();
+function w(r, e, t, n) {
+  if (e === null)
+    return r.typeName == "google.protobuf.NullValue" ? 0 : n ? r.values[0].number : y;
+  switch (typeof e) {
+    case "number":
+      if (Number.isInteger(e))
+        return e;
+      break;
+    case "string":
+      const a = r.values.find((s) => s.name === e);
+      if (a !== void 0)
+        return a.number;
+      if (t)
+        return p;
+      break;
+  }
+  throw new Error(`cannot decode ${r} from JSON: ${u(e)}`);
+}
+const y = Symbol();
+function b(r, e, t) {
+  if (e === null)
+    return t ? x(r.scalar, !1) : y;
+  switch (r.scalar) {
+    // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+    // Either numbers or strings are accepted. Exponent notation is also accepted.
+    case i.DOUBLE:
+    case i.FLOAT:
+      if (e === "NaN")
+        return NaN;
+      if (e === "Infinity")
+        return Number.POSITIVE_INFINITY;
+      if (e === "-Infinity")
+        return Number.NEGATIVE_INFINITY;
+      if (typeof e == "number") {
+        if (Number.isNaN(e))
+          throw new l(r, "unexpected NaN number");
+        if (!Number.isFinite(e))
+          throw new l(r, "unexpected infinite number");
+        break;
+      }
+      if (typeof e == "string") {
+        if (e === "" || e.trim().length !== e.length)
+          break;
+        const n = Number(e);
+        if (!Number.isFinite(n))
+          break;
+        return n;
+      }
+      break;
+    // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+    case i.INT32:
+    case i.FIXED32:
+    case i.SFIXED32:
+    case i.SINT32:
+    case i.UINT32:
+      return F(e);
+    // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+    // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+    case i.BYTES:
+      if (typeof e == "string") {
+        if (e === "")
+          return new Uint8Array(0);
+        try {
+          return D(e);
+        } catch (n) {
+          const a = n instanceof Error ? n.message : String(n);
+          throw new l(r, a);
+        }
+      }
+      break;
+  }
+  return e;
+}
+function z(r, e) {
+  switch (r) {
+    case i.BOOL:
+      switch (e) {
+        case "true":
+          return !0;
+        case "false":
+          return !1;
+      }
+      return e;
+    case i.INT32:
+    case i.FIXED32:
+    case i.UINT32:
+    case i.SFIXED32:
+    case i.SINT32:
+      return F(e);
+    default:
+      return e;
+  }
+}
+function F(r) {
+  if (typeof r == "string") {
+    if (r === "" || r.trim().length !== r.length)
+      return r;
+    const e = Number(r);
+    return Number.isNaN(e) ? r : e;
+  }
+  return r;
+}
+function I(r, e) {
+  try {
+    return JSON.parse(r);
+  } catch (t) {
+    const n = t instanceof Error ? t.message : String(t);
+    throw new Error(
+      `cannot decode message ${e} from JSON: ${n}`,
+      // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces
+      { cause: t }
+    );
+  }
+}
+function H(r, e, t) {
+  if (!r.desc.typeName.startsWith("google.protobuf."))
+    return !1;
+  switch (r.desc.typeName) {
+    case "google.protobuf.Any":
+      return Q(r.message, e, t), !0;
+    case "google.protobuf.Timestamp":
+      return j(r.message, e), !0;
+    case "google.protobuf.Duration":
+      return ee(r.message, e), !0;
+    case "google.protobuf.FieldMask":
+      return re(r.message, e), !0;
+    case "google.protobuf.Struct":
+      return v(r.message, e), !0;
+    case "google.protobuf.Value":
+      return h(r.message, e), !0;
+    case "google.protobuf.ListValue":
+      return A(r.message, e), !0;
+    default:
+      if (M(r.desc)) {
+        const n = r.desc.fields[0];
+        return e === null ? r.clear(n) : r.set(n, b(n, e, !0)), !0;
+      }
+      return !1;
+  }
+}
+function Q(r, e, t) {
+  var n;
+  if (e === null || Array.isArray(e) || typeof e != "object")
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: expected object but got ${u(e)}`);
+  if (Object.keys(e).length == 0)
+    return;
+  const a = e["@type"];
+  if (typeof a != "string" || a == "")
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: "@type" is empty`);
+  const s = a.includes("/") ? a.substring(a.lastIndexOf("/") + 1) : a;
+  if (!s.length)
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: "@type" is invalid`);
+  const o = (n = t.registry) === null || n === void 0 ? void 0 : n.getMessage(s);
+  if (!o)
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${a} is not in the type registry`);
+  const f = g(o);
+  if (s.startsWith("google.protobuf.") && Object.prototype.hasOwnProperty.call(e, "value")) {
+    const c = e.value;
+    d(f, c, t);
+  } else {
+    const c = Object.assign({}, e);
+    delete c["@type"], d(f, c, t);
+  }
+  Z(f.desc, f.message, r);
+}
+function j(r, e) {
+  if (typeof e != "string")
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${u(e)}`);
+  const t = e.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]{1,9}))?(?:Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+  if (!t)
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: invalid RFC 3339 string`);
+  const n = Date.parse(
+    // biome-ignore format: want this to read well
+    t[1] + "-" + t[2] + "-" + t[3] + "T" + t[4] + ":" + t[5] + ":" + t[6] + (t[8] ? t[8] : "Z")
+  );
+  if (Number.isNaN(n))
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: invalid RFC 3339 string`);
+  if (n < Date.parse("0001-01-01T00:00:00Z") || n > Date.parse("9999-12-31T23:59:59Z"))
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+  r.seconds = k.parse(n / 1e3), r.nanos = 0, t[7] && (r.nanos = parseInt("1" + t[7] + "0".repeat(9 - t[7].length)) - 1e9);
+}
+function ee(r, e) {
+  if (typeof e != "string")
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${u(e)}`);
+  const t = e.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
+  if (t === null)
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${u(e)}`);
+  const n = Number(t[1]);
+  if (n > 315576e6 || n < -315576e6)
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${u(e)}`);
+  if (r.seconds = k.parse(n), typeof t[2] != "string")
+    return;
+  const a = t[2] + "0".repeat(9 - t[2].length);
+  r.nanos = parseInt(a), (n < 0 || Object.is(n, -0)) && (r.nanos = -r.nanos);
+}
+function re(r, e) {
+  if (typeof e != "string")
+    throw new Error(`cannot decode message ${r.$typeName} from JSON: ${u(e)}`);
+  if (e === "")
+    return;
+  function t(n) {
+    if (n.includes("_"))
+      throw new Error(`cannot decode message ${r.$typeName} from JSON: path names must be lowerCamelCase`);
+    const a = n.replace(/[A-Z]/g, (s) => "_" + s.toLowerCase());
+    return a[0] === "_" ? a.substring(1) : a;
+  }
+  r.paths = e.split(",").map(t);
+}
+function v(r, e) {
+  if (typeof e != "object" || e == null || Array.isArray(e))
+    throw new Error(`cannot decode message ${r.$typeName} from JSON ${u(e)}`);
+  for (const [t, n] of Object.entries(e)) {
+    const a = N(J);
+    h(a, n), r.fields[t] = a;
+  }
+}
+function h(r, e) {
+  switch (typeof e) {
+    case "number":
+      r.kind = { case: "numberValue", value: e };
+      break;
+    case "string":
+      r.kind = { case: "stringValue", value: e };
+      break;
+    case "boolean":
+      r.kind = { case: "boolValue", value: e };
+      break;
+    case "object":
+      if (e === null)
+        r.kind = { case: "nullValue", value: _.NULL_VALUE };
+      else if (Array.isArray(e)) {
+        const t = N(C);
+        A(t, e), r.kind = { case: "listValue", value: t };
+      } else {
+        const t = N(W);
+        v(t, e), r.kind = { case: "structValue", value: t };
+      }
+      break;
+    default:
+      throw new Error(`cannot decode message ${r.$typeName} from JSON ${u(e)}`);
+  }
+  return r;
+}
+function A(r, e) {
+  if (!Array.isArray(e))
+    throw new Error(`cannot decode message ${r.$typeName} from JSON ${u(e)}`);
+  for (const t of e) {
+    const n = N(J);
+    h(n, t), r.values.push(n);
+  }
+}
+export {
+  we as enumFromJson,
+  R as fromJson,
+  pe as fromJsonString,
+  ye as isEnumJson,
+  X as mergeFromJson,
+  Ne as mergeFromJsonString
+};

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

@@ -0,0 +1,49 @@
+import "./types.js";
+import { isMessage as t } from "./is-message.js";
+import { create as n } from "./create.js";
+import { clone as s } from "./clone.js";
+import { ScalarType as x } from "./descriptors.js";
+import { equals as f } from "./equals.js";
+import { clearField as l, isFieldSet as J } from "./fields.js";
+import { createFileRegistry as u, createMutableRegistry as y, createRegistry as E, maximumEdition as F, minimumEdition as S } from "./registry.js";
+import { toBinary as B } from "./to-binary.js";
+import { fromBinary as h, mergeFromBinary as M } from "./from-binary.js";
+import { enumToJson as T, toJson as b, toJsonString as q } from "./to-json.js";
+import { enumFromJson as j, fromJson as k, fromJsonString as v, isEnumJson as w, mergeFromJson as z, mergeFromJsonString as A } from "./from-json.js";
+import { merge as D } from "./merge.js";
+import { clearExtension as H, getExtension as K, getOption as L, hasExtension as N, hasOption as P, setExtension as Q } from "./extensions.js";
+import { protoInt64 as V } from "./proto-int64.js";
+export {
+  x as ScalarType,
+  H as clearExtension,
+  l as clearField,
+  s as clone,
+  n as create,
+  u as createFileRegistry,
+  y as createMutableRegistry,
+  E as createRegistry,
+  j as enumFromJson,
+  T as enumToJson,
+  f as equals,
+  h as fromBinary,
+  k as fromJson,
+  v as fromJsonString,
+  K as getExtension,
+  L as getOption,
+  N as hasExtension,
+  P as hasOption,
+  w as isEnumJson,
+  J as isFieldSet,
+  t as isMessage,
+  F as maximumEdition,
+  D as merge,
+  M as mergeFromBinary,
+  z as mergeFromJson,
+  A as mergeFromJsonString,
+  S as minimumEdition,
+  V as protoInt64,
+  Q as setExtension,
+  B as toBinary,
+  b as toJson,
+  q as toJsonString
+};

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

@@ -0,0 +1,33 @@
+import { reflect as a } from "./reflect/reflect.js";
+function g(n, s, o) {
+  c(a(n, s), a(n, o));
+}
+function c(n, s) {
+  var o, t;
+  const f = s.message.$unknown;
+  f !== void 0 && f.length > 0 && ((o = (t = n.message).$unknown) !== null && o !== void 0 || (t.$unknown = []), n.message.$unknown.push(...f));
+  for (const e of n.fields)
+    if (s.isSet(e))
+      switch (e.fieldKind) {
+        case "scalar":
+        case "enum":
+          n.set(e, s.get(e));
+          break;
+        case "message":
+          n.isSet(e) ? c(n.get(e), s.get(e)) : n.set(e, s.get(e));
+          break;
+        case "list":
+          const l = n.get(e);
+          for (const i of s.get(e))
+            l.add(i);
+          break;
+        case "map":
+          const k = n.get(e);
+          for (const [i, m] of s.get(e))
+            k.set(i, m);
+          break;
+      }
+}
+export {
+  g as merge
+};

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

@@ -1,8 +1,17 @@
+const o = [
+  "FieldValueInvalidError",
+  "FieldListRangeError",
+  "ForeignFieldError"
+];
 class l extends Error {
-  constructor(r, e, s = "FieldValueInvalidError") {
-    super(e), this.name = s, this.field = () => r;
+  constructor(e, i, n = "FieldValueInvalidError") {
+    super(i), this.name = n, this.field = () => e;
   }
 }
+function d(r) {
+  return r instanceof Error && o.includes(r.name) && "field" in r && typeof r.field == "function";
+}
 export {
-  l as FieldError
+  l as FieldError,
+  d as isFieldError
 };

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

@@ -2,34 +2,38 @@ import { unsafeLocal as f } from "./unsafe.js";
 function s(e) {
   return e !== null && typeof e == "object" && !Array.isArray(e);
 }
-function c(e, t) {
-  var d, l, o, u;
+function a(e) {
+  return e !== null && typeof e == "object" && "case" in e && (typeof e.case == "string" && "value" in e && e.value != null || e.case === void 0 && (!("value" in e) || e.value === void 0));
+}
+function m(e, t) {
+  var d, u, l, o;
   if (s(e) && f in e && "add" in e && "field" in e && typeof e.field == "function") {
     if (t !== void 0) {
       const n = t, i = e.field();
-      return n.listKind == i.listKind && n.scalar === i.scalar && ((d = n.message) === null || d === void 0 ? void 0 : d.typeName) === ((l = i.message) === null || l === void 0 ? void 0 : l.typeName) && ((o = n.enum) === null || o === void 0 ? void 0 : o.typeName) === ((u = i.enum) === null || u === void 0 ? void 0 : u.typeName);
+      return n.listKind == i.listKind && n.scalar === i.scalar && ((d = n.message) === null || d === void 0 ? void 0 : d.typeName) === ((u = i.message) === null || u === void 0 ? void 0 : u.typeName) && ((l = n.enum) === null || l === void 0 ? void 0 : l.typeName) === ((o = i.enum) === null || o === void 0 ? void 0 : o.typeName);
     }
     return !0;
   }
   return !1;
 }
-function m(e, t) {
-  var d, l, o, u;
+function p(e, t) {
+  var d, u, l, o;
   if (s(e) && f in e && "has" in e && "field" in e && typeof e.field == "function") {
     if (t !== void 0) {
       const n = t, i = e.field();
-      return n.mapKey === i.mapKey && n.mapKind == i.mapKind && n.scalar === i.scalar && ((d = n.message) === null || d === void 0 ? void 0 : d.typeName) === ((l = i.message) === null || l === void 0 ? void 0 : l.typeName) && ((o = n.enum) === null || o === void 0 ? void 0 : o.typeName) === ((u = i.enum) === null || u === void 0 ? void 0 : u.typeName);
+      return n.mapKey === i.mapKey && n.mapKind == i.mapKind && n.scalar === i.scalar && ((d = n.message) === null || d === void 0 ? void 0 : d.typeName) === ((u = i.message) === null || u === void 0 ? void 0 : u.typeName) && ((l = n.enum) === null || l === void 0 ? void 0 : l.typeName) === ((o = i.enum) === null || o === void 0 ? void 0 : o.typeName);
     }
     return !0;
   }
   return !1;
 }
-function p(e, t) {
+function v(e, t) {
   return s(e) && f in e && "desc" in e && s(e.desc) && e.desc.kind === "message" && (t === void 0 || e.desc.typeName == t.typeName);
 }
 export {
   s as isObject,
-  c as isReflectList,
-  m as isReflectMap,
-  p as isReflectMessage
+  a as isOneofADT,
+  m as isReflectList,
+  p as isReflectMap,
+  v as isReflectMessage
 };

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

@@ -1,11 +1,30 @@
+function c(e) {
+  switch (e.kind) {
+    case "field":
+    case "oneof":
+    case "rpc":
+      return e.parent.typeName + "." + e.name;
+    case "enum_value": {
+      const a = e.parent.parent ? e.parent.parent.typeName : e.parent.file.proto.package;
+      return a + (a.length > 0 ? "." : "") + e.name;
+    }
+    case "service":
+    case "message":
+    case "enum":
+    case "extension":
+      return e.typeName;
+    case "file":
+      return e.proto.name;
+  }
+}
 function o(e) {
-  let s = !1;
-  const c = [];
-  for (let a = 0; a < e.length; a++) {
-    let t = e.charAt(a);
+  let a = !1;
+  const r = [];
+  for (let n = 0; n < e.length; n++) {
+    let t = e.charAt(n);
     switch (t) {
       case "_":
-        s = !0;
+        a = !0;
         break;
       case "0":
       case "1":
@@ -17,26 +36,27 @@ function o(e) {
       case "7":
       case "8":
       case "9":
-        c.push(t), s = !1;
+        r.push(t), a = !1;
         break;
       default:
-        s && (s = !1, t = t.toUpperCase()), c.push(t);
+        a && (a = !1, t = t.toUpperCase()), r.push(t);
         break;
     }
   }
-  return c.join("");
+  return r.join("");
 }
-const r = /* @__PURE__ */ new Set([
+const s = /* @__PURE__ */ new Set([
   // names reserved by JavaScript
   "constructor",
   "toString",
   "toJSON",
   "valueOf"
 ]);
-function f(e) {
-  return r.has(e) ? e + "$" : e;
+function p(e) {
+  return s.has(e) ? e + "$" : e;
 }
 export {
   o as protoCamelCase,
-  f as safeObjectProperty
+  c as qualifiedName,
+  p as safeObjectProperty
 };