@hashgraphonline/standards-sdk 0.0.67 → 0.0.68

package/dist/es/standards-sdk.es56.js

@@ -1,47 +1,9 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Typed } from "./standards-sdk.es62.js";
-import { Coder, WordSize } from "./standards-sdk.es49.js";
-import { defineProperties } from "./standards-sdk.es60.js";
-import { getBigInt, mask, toTwos, fromTwos } from "./standards-sdk.es61.js";
-const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
-const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-class NumberCoder extends Coder {
-  constructor(size, signed, localName) {
-    const name = (signed ? "int" : "uint") + size * 8;
-    super(name, name, localName, false);
-    __publicField(this, "size");
-    __publicField(this, "signed");
-    defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
-  }
-  defaultValue() {
-    return 0;
-  }
-  encode(writer, _value) {
-    let value = getBigInt(Typed.dereference(_value, this.type));
-    let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);
-    if (this.signed) {
-      let bounds = mask(maxUintValue, this.size * 8 - 1);
-      if (value > bounds || value < -(bounds + BN_1)) {
-        this._throwError("value out-of-bounds", _value);
-      }
-      value = toTwos(value, 8 * WordSize);
-    } else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {
-      this._throwError("value out-of-bounds", _value);
-    }
-    return writer.writeValue(value);
-  }
-  decode(reader) {
-    let value = mask(reader.readValue(), this.size * 8);
-    if (this.signed) {
-      value = fromTwos(value, this.size * 8);
-    }
-    return value;
-  }
+import { keccak256 } from "./standards-sdk.es53.js";
+import { toUtf8Bytes } from "./standards-sdk.es57.js";
+function id(value) {
+  return keccak256(toUtf8Bytes(value));
 }
 export {
-  NumberCoder
+  id
 };
 //# sourceMappingURL=standards-sdk.es56.js.map

package/dist/es/standards-sdk.es56.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es56.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/number.js"],"sourcesContent":["import { defineProperties, fromTwos, getBigInt, mask, toTwos } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, WordSize } from \"./abstract-coder.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_MAX_UINT256 = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\n/**\n *  @_ignore\n */\nexport class NumberCoder extends Coder {\n    size;\n    signed;\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        defineProperties(this, { size, signed }, { size: \"number\", signed: \"boolean\" });\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, _value) {\n        let value = getBigInt(Typed.dereference(_value, this.type));\n        // Check bounds are safe for encoding\n        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);\n        if (this.signed) {\n            let bounds = mask(maxUintValue, (this.size * 8) - 1);\n            if (value > bounds || value < -(bounds + BN_1)) {\n                this._throwError(\"value out-of-bounds\", _value);\n            }\n            value = toTwos(value, 8 * WordSize);\n        }\n        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {\n            this._throwError(\"value out-of-bounds\", _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        let value = mask(reader.readValue(), this.size * 8);\n        if (this.signed) {\n            value = fromTwos(value, this.size * 8);\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=number.js.map"],"names":[],"mappings":";;;;;;;AAGA,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,iBAAiB,OAAO,oEAAoE;AAI3F,MAAM,oBAAoB,MAAM;AAAA,EAGnC,YAAY,MAAM,QAAQ,WAAW;AACjC,UAAM,QAAS,SAAS,QAAQ,UAAW,OAAO;AAClD,UAAM,MAAM,MAAM,WAAW,KAAK;AAJtC;AACA;AAII,qBAAiB,MAAM,EAAE,MAAM,OAAM,GAAI,EAAE,MAAM,UAAU,QAAQ,WAAW;AAAA,EACtF;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,QAAQ,UAAU,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;AAE1D,QAAI,eAAe,KAAK,gBAAgB,WAAW,CAAC;AACpD,QAAI,KAAK,QAAQ;AACb,UAAI,SAAS,KAAK,cAAe,KAAK,OAAO,IAAK,CAAC;AACnD,UAAI,QAAQ,UAAU,QAAQ,EAAE,SAAS,OAAO;AAC5C,aAAK,YAAY,uBAAuB,MAAM;AAAA,MAC9D;AACY,cAAQ,OAAO,OAAO,IAAI,QAAQ;AAAA,IAC9C,WACiB,QAAQ,QAAQ,QAAQ,KAAK,cAAc,KAAK,OAAO,CAAC,GAAG;AAChE,WAAK,YAAY,uBAAuB,MAAM;AAAA,IAC1D;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,QAAI,QAAQ,KAAK,OAAO,UAAS,GAAI,KAAK,OAAO,CAAC;AAClD,QAAI,KAAK,QAAQ;AACb,cAAQ,SAAS,OAAO,KAAK,OAAO,CAAC;AAAA,IACjD;AACQ,WAAO;AAAA,EACf;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es56.js","sources":["../../node_modules/ethers/lib.esm/hash/id.js"],"sourcesContent":["import { keccak256 } from \"../crypto/index.js\";\nimport { toUtf8Bytes } from \"../utils/index.js\";\n/**\n *  A simple hashing function which operates on UTF-8 strings to\n *  compute an 32-byte identifier.\n *\n *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes\n *  the [[keccak256]].\n *\n *  @example:\n *    id(\"hello world\")\n *    //_result:\n */\nexport function id(value) {\n    return keccak256(toUtf8Bytes(value));\n}\n//# sourceMappingURL=id.js.map"],"names":[],"mappings":";;AAaO,SAAS,GAAG,OAAO;AACtB,SAAO,UAAU,YAAY,KAAK,CAAC;AACvC;","x_google_ignoreList":[0]}

package/dist/es/standards-sdk.es57.js

@@ -1,21 +1,146 @@
-import { toUtf8Bytes, toUtf8String } from "./standards-sdk.es47.js";
-import { Typed } from "./standards-sdk.es62.js";
-import { DynamicBytesCoder } from "./standards-sdk.es53.js";
-class StringCoder extends DynamicBytesCoder {
-  constructor(localName) {
-    super("string", localName);
+import { getBytes } from "./standards-sdk.es55.js";
+import { assertArgument } from "./standards-sdk.es70.js";
+function errorFunc(reason, offset, bytes, output, badCodepoint) {
+  assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+}
+function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+    let i = 0;
+    for (let o = offset + 1; o < bytes.length; o++) {
+      if (bytes[o] >> 6 !== 2) {
+        break;
+      }
+      i++;
+    }
+    return i;
+  }
+  if (reason === "OVERRUN") {
+    return bytes.length - offset - 1;
+  }
+  return 0;
+}
+function replaceFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "OVERLONG") {
+    assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+    output.push(badCodepoint);
+    return 0;
   }
-  defaultValue() {
-    return "";
+  output.push(65533);
+  return ignoreFunc(reason, offset, bytes);
+}
+const Utf8ErrorFuncs = Object.freeze({
+  error: errorFunc,
+  ignore: ignoreFunc,
+  replace: replaceFunc
+});
+function getUtf8CodePoints(_bytes, onError) {
+  if (onError == null) {
+    onError = Utf8ErrorFuncs.error;
   }
-  encode(writer, _value) {
-    return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
+  const bytes = getBytes(_bytes, "bytes");
+  const result = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const c = bytes[i++];
+    if (c >> 7 === 0) {
+      result.push(c);
+      continue;
+    }
+    let extraLength = null;
+    let overlongMask = null;
+    if ((c & 224) === 192) {
+      extraLength = 1;
+      overlongMask = 127;
+    } else if ((c & 240) === 224) {
+      extraLength = 2;
+      overlongMask = 2047;
+    } else if ((c & 248) === 240) {
+      extraLength = 3;
+      overlongMask = 65535;
+    } else {
+      if ((c & 192) === 128) {
+        i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
+      } else {
+        i += onError("BAD_PREFIX", i - 1, bytes, result);
+      }
+      continue;
+    }
+    if (i - 1 + extraLength >= bytes.length) {
+      i += onError("OVERRUN", i - 1, bytes, result);
+      continue;
+    }
+    let res = c & (1 << 8 - extraLength - 1) - 1;
+    for (let j = 0; j < extraLength; j++) {
+      let nextChar = bytes[i];
+      if ((nextChar & 192) != 128) {
+        i += onError("MISSING_CONTINUE", i, bytes, result);
+        res = null;
+        break;
+      }
+      res = res << 6 | nextChar & 63;
+      i++;
+    }
+    if (res === null) {
+      continue;
+    }
+    if (res > 1114111) {
+      i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res >= 55296 && res <= 57343) {
+      i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res <= overlongMask) {
+      i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    result.push(res);
   }
-  decode(reader) {
-    return toUtf8String(super.decode(reader));
+  return result;
+}
+function toUtf8Bytes(str, form) {
+  assertArgument(typeof str === "string", "invalid string value", "str", str);
+  let result = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      result.push(c);
+    } else if (c < 2048) {
+      result.push(c >> 6 | 192);
+      result.push(c & 63 | 128);
+    } else if ((c & 64512) == 55296) {
+      i++;
+      const c2 = str.charCodeAt(i);
+      assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
+      const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+      result.push(pair >> 18 | 240);
+      result.push(pair >> 12 & 63 | 128);
+      result.push(pair >> 6 & 63 | 128);
+      result.push(pair & 63 | 128);
+    } else {
+      result.push(c >> 12 | 224);
+      result.push(c >> 6 & 63 | 128);
+      result.push(c & 63 | 128);
+    }
   }
+  return new Uint8Array(result);
+}
+function _toUtf8String(codePoints) {
+  return codePoints.map((codePoint) => {
+    if (codePoint <= 65535) {
+      return String.fromCharCode(codePoint);
+    }
+    codePoint -= 65536;
+    return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
+  }).join("");
+}
+function toUtf8String(bytes, onError) {
+  return _toUtf8String(getUtf8CodePoints(bytes, onError));
 }
 export {
-  StringCoder
+  Utf8ErrorFuncs,
+  toUtf8Bytes,
+  toUtf8String
 };
 //# sourceMappingURL=standards-sdk.es57.js.map

package/dist/es/standards-sdk.es57.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es57.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/string.js"],"sourcesContent":["import { toUtf8Bytes, toUtf8String } from \"../../utils/utf8.js\";\nimport { Typed } from \"../typed.js\";\nimport { DynamicBytesCoder } from \"./bytes.js\";\n/**\n *  @_ignore\n */\nexport class StringCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"string\", localName);\n    }\n    defaultValue() {\n        return \"\";\n    }\n    encode(writer, _value) {\n        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, \"string\")));\n    }\n    decode(reader) {\n        return toUtf8String(super.decode(reader));\n    }\n}\n//# sourceMappingURL=string.js.map"],"names":[],"mappings":";;;AAMO,MAAM,oBAAoB,kBAAkB;AAAA,EAC/C,YAAY,WAAW;AACnB,UAAM,UAAU,SAAS;AAAA,EACjC;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,WAAO,MAAM,OAAO,QAAQ,YAAY,MAAM,YAAY,QAAQ,QAAQ,CAAC,CAAC;AAAA,EACpF;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,aAAa,MAAM,OAAO,MAAM,CAAC;AAAA,EAChD;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es57.js","sources":["../../node_modules/ethers/lib.esm/utils/utf8.js"],"sourcesContent":["/**\n *  Using strings in Ethereum (or any security-basd system) requires\n *  additional care. These utilities attempt to mitigate some of the\n *  safety issues as well as provide the ability to recover and analyse\n *  strings.\n *\n *  @_subsection api/utils:Strings and UTF-8  [about-strings]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument, assertNormalize } from \"./errors.js\";\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === \"BAD_PREFIX\" || reason === \"UNEXPECTED_CONTINUE\") {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === \"OVERRUN\") {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === \"OVERLONG\") {\n        assertArgument(typeof (badCodepoint) === \"number\", \"invalid bad code point for replacement\", \"badCodepoint\", badCodepoint);\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n/**\n *  A handful of popular, built-in UTF-8 error handling strategies.\n *\n *  **``\"error\"``** - throws on ANY illegal UTF-8 sequence or\n *  non-canonical (overlong) codepoints (this is the default)\n *\n *  **``\"ignore\"``** - silently drops any illegal UTF-8 sequence\n *  and accepts non-canonical (overlong) codepoints\n *\n *  **``\"replace\"``** - replace any illegal UTF-8 sequence with the\n *  UTF-8 replacement character (i.e. ``\"\\\\ufffd\"``) and accepts\n *  non-canonical (overlong) codepoints\n *\n *  @returns: Record<\"error\" | \"ignore\" | \"replace\", Utf8ErrorFunc>\n */\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(_bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    const bytes = getBytes(_bytes, \"bytes\");\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(\"UNEXPECTED_CONTINUE\", i - 1, bytes, result);\n            }\n            else {\n                i += onError(\"BAD_PREFIX\", i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(\"OVERRUN\", i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(\"MISSING_CONTINUE\", i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(\"OUT_OF_RANGE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(\"UTF16_SURROGATE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(\"OVERLONG\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n/**\n *  Returns the UTF-8 byte representation of %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8Bytes(str, form) {\n    assertArgument(typeof (str) === \"string\", \"invalid string value\", \"str\", str);\n    if (form != null) {\n        assertNormalize(form);\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), \"invalid surrogate pair\", \"str\", str);\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return new Uint8Array(result);\n}\n;\n//export \nfunction _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\n/**\n *  Returns the string represented by the UTF-8 data %%bytes%%.\n *\n *  When %%onError%% function is specified, it is called on UTF-8\n *  errors allowing recovery using the [[Utf8ErrorFunc]] API.\n *  (default: [error](Utf8ErrorFuncs))\n */\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\n/**\n *  Returns the UTF-8 code-points for %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8CodePoints(str, form) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/es/standards-sdk.es58.js

@@ -1,64 +1,198 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { defineProperties } from "./standards-sdk.es60.js";
-import { Typed } from "./standards-sdk.es62.js";
-import { Coder } from "./standards-sdk.es49.js";
-import { pack, unpack } from "./standards-sdk.es51.js";
-class TupleCoder extends Coder {
-  constructor(coders, localName) {
-    let dynamic = false;
-    const types = [];
-    coders.forEach((coder) => {
-      if (coder.dynamic) {
-        dynamic = true;
-      }
-      types.push(coder.type);
-    });
-    const type = "tuple(" + types.join(",") + ")";
-    super("tuple", type, localName, dynamic);
-    __publicField(this, "coders");
-    defineProperties(this, { coders: Object.freeze(coders.slice()) });
-  }
-  defaultValue() {
-    const values = [];
-    this.coders.forEach((coder) => {
-      values.push(coder.defaultValue());
-    });
-    const uniqueNames = this.coders.reduce((accum, coder) => {
-      const name = coder.localName;
-      if (name) {
-        if (!accum[name]) {
-          accum[name] = 0;
-        }
-        accum[name]++;
-      }
-      return accum;
-    }, {});
-    this.coders.forEach((coder, index) => {
-      let name = coder.localName;
-      if (!name || uniqueNames[name] !== 1) {
-        return;
-      }
-      if (name === "length") {
-        name = "_length";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _AbiCoder_instances, getCoder_fn;
+import { Writer, Reader } from "./standards-sdk.es59.js";
+import { AddressCoder } from "./standards-sdk.es60.js";
+import { ArrayCoder } from "./standards-sdk.es61.js";
+import { BooleanCoder } from "./standards-sdk.es62.js";
+import { BytesCoder } from "./standards-sdk.es63.js";
+import { FixedBytesCoder } from "./standards-sdk.es64.js";
+import { NullCoder } from "./standards-sdk.es65.js";
+import { NumberCoder } from "./standards-sdk.es66.js";
+import { StringCoder } from "./standards-sdk.es67.js";
+import { TupleCoder } from "./standards-sdk.es68.js";
+import { ParamType } from "./standards-sdk.es69.js";
+import { assertArgument, assertArgumentCount, makeError } from "./standards-sdk.es70.js";
+import { getBytes, hexlify } from "./standards-sdk.es55.js";
+import { getAddress } from "./standards-sdk.es71.js";
+const PanicReasons = /* @__PURE__ */ new Map();
+PanicReasons.set(0, "GENERIC_PANIC");
+PanicReasons.set(1, "ASSERT_FALSE");
+PanicReasons.set(17, "OVERFLOW");
+PanicReasons.set(18, "DIVIDE_BY_ZERO");
+PanicReasons.set(33, "ENUM_RANGE_ERROR");
+PanicReasons.set(34, "BAD_STORAGE_DATA");
+PanicReasons.set(49, "STACK_UNDERFLOW");
+PanicReasons.set(50, "ARRAY_RANGE_ERROR");
+PanicReasons.set(65, "OUT_OF_MEMORY");
+PanicReasons.set(81, "UNINITIALIZED_FUNCTION_CALL");
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+let defaultCoder = null;
+let defaultMaxInflation = 1024;
+function getBuiltinCallException(action, tx, data, abiCoder) {
+  let message = "missing revert data";
+  let reason = null;
+  const invocation = null;
+  let revert = null;
+  if (data) {
+    message = "execution reverted";
+    const bytes = getBytes(data);
+    data = hexlify(data);
+    if (bytes.length === 0) {
+      message += " (no data present; likely require(false) occurred";
+      reason = "require(false)";
+    } else if (bytes.length % 32 !== 4) {
+      message += " (could not decode reason; invalid data length)";
+    } else if (hexlify(bytes.slice(0, 4)) === "0x08c379a0") {
+      try {
+        reason = abiCoder.decode(["string"], bytes.slice(4))[0];
+        revert = {
+          signature: "Error(string)",
+          name: "Error",
+          args: [reason]
+        };
+        message += `: ${JSON.stringify(reason)}`;
+      } catch (error) {
+        message += " (could not decode reason; invalid string data)";
       }
-      if (values[name] != null) {
-        return;
+    } else if (hexlify(bytes.slice(0, 4)) === "0x4e487b71") {
+      try {
+        const code = Number(abiCoder.decode(["uint256"], bytes.slice(4))[0]);
+        revert = {
+          signature: "Panic(uint256)",
+          name: "Panic",
+          args: [code]
+        };
+        reason = `Panic due to ${PanicReasons.get(code) || "UNKNOWN"}(${code})`;
+        message += `: ${reason}`;
+      } catch (error) {
+        message += " (could not decode panic code)";
       }
-      values[name] = values[index];
-    });
-    return Object.freeze(values);
+    } else {
+      message += " (unknown custom error)";
+    }
   }
-  encode(writer, _value) {
-    const value = Typed.dereference(_value, "tuple");
-    return pack(writer, this.coders, value);
-  }
-  decode(reader) {
-    return unpack(reader, this.coders);
+  const transaction = {
+    to: tx.to ? getAddress(tx.to) : null,
+    data: tx.data || "0x"
+  };
+  if (tx.from) {
+    transaction.from = getAddress(tx.from);
   }
+  return makeError(message, "CALL_EXCEPTION", {
+    action,
+    data,
+    reason,
+    transaction,
+    invocation,
+    revert
+  });
 }
+const _AbiCoder = class _AbiCoder {
+  constructor() {
+    __privateAdd(this, _AbiCoder_instances);
+  }
+  /**
+   *  Get the default values for the given %%types%%.
+   *
+   *  For example, a ``uint`` is by default ``0`` and ``bool``
+   *  is by default ``false``.
+   */
+  getDefaultValue(types) {
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    return coder.defaultValue();
+  }
+  /**
+   *  Encode the %%values%% as the %%types%% into ABI data.
+   *
+   *  @returns DataHexstring
+   */
+  encode(types, values) {
+    assertArgumentCount(values.length, types.length, "types/values length mismatch");
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    const writer = new Writer();
+    coder.encode(writer, values);
+    return writer.data;
+  }
+  /**
+   *  Decode the ABI %%data%% as the %%types%% into values.
+   *
+   *  If %%loose%% decoding is enabled, then strict padding is
+   *  not enforced. Some older versions of Solidity incorrectly
+   *  padded event data emitted from ``external`` functions.
+   */
+  decode(types, data, loose) {
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    return coder.decode(new Reader(data, loose, defaultMaxInflation));
+  }
+  static _setDefaultMaxInflation(value) {
+    assertArgument(typeof value === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+    defaultMaxInflation = value;
+  }
+  /**
+   *  Returns the shared singleton instance of a default [[AbiCoder]].
+   *
+   *  On the first call, the instance is created internally.
+   */
+  static defaultAbiCoder() {
+    if (defaultCoder == null) {
+      defaultCoder = new _AbiCoder();
+    }
+    return defaultCoder;
+  }
+  /**
+   *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+   *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+   *  the Transaction %%tx%%.
+   */
+  static getBuiltinCallException(action, tx, data) {
+    return getBuiltinCallException(action, tx, data, _AbiCoder.defaultAbiCoder());
+  }
+};
+_AbiCoder_instances = new WeakSet();
+getCoder_fn = function(param) {
+  if (param.isArray()) {
+    return new ArrayCoder(__privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, param.arrayChildren), param.arrayLength, param.name);
+  }
+  if (param.isTuple()) {
+    return new TupleCoder(param.components.map((c) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, c)), param.name);
+  }
+  switch (param.baseType) {
+    case "address":
+      return new AddressCoder(param.name);
+    case "bool":
+      return new BooleanCoder(param.name);
+    case "string":
+      return new StringCoder(param.name);
+    case "bytes":
+      return new BytesCoder(param.name);
+    case "":
+      return new NullCoder(param.name);
+  }
+  let match = param.type.match(paramTypeNumber);
+  if (match) {
+    let size = parseInt(match[2] || "256");
+    assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid " + match[1] + " bit length", "param", param);
+    return new NumberCoder(size / 8, match[1] === "int", param.name);
+  }
+  match = param.type.match(paramTypeBytes);
+  if (match) {
+    let size = parseInt(match[1]);
+    assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
+    return new FixedBytesCoder(size, param.name);
+  }
+  assertArgument(false, "invalid type", "type", param.type);
+};
+let AbiCoder = _AbiCoder;
 export {
-  TupleCoder
+  AbiCoder
 };
 //# sourceMappingURL=standards-sdk.es58.js.map

package/dist/es/standards-sdk.es58.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es58.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/tuple.js"],"sourcesContent":["import { defineProperties } from \"../../utils/properties.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\nimport { pack, unpack } from \"./array.js\";\n/**\n *  @_ignore\n */\nexport class TupleCoder extends Coder {\n    coders;\n    constructor(coders, localName) {\n        let dynamic = false;\n        const types = [];\n        coders.forEach((coder) => {\n            if (coder.dynamic) {\n                dynamic = true;\n            }\n            types.push(coder.type);\n        });\n        const type = (\"tuple(\" + types.join(\",\") + \")\");\n        super(\"tuple\", type, localName, dynamic);\n        defineProperties(this, { coders: Object.freeze(coders.slice()) });\n    }\n    defaultValue() {\n        const values = [];\n        this.coders.forEach((coder) => {\n            values.push(coder.defaultValue());\n        });\n        // We only output named properties for uniquely named coders\n        const uniqueNames = this.coders.reduce((accum, coder) => {\n            const name = coder.localName;\n            if (name) {\n                if (!accum[name]) {\n                    accum[name] = 0;\n                }\n                accum[name]++;\n            }\n            return accum;\n        }, {});\n        // Add named values\n        this.coders.forEach((coder, index) => {\n            let name = coder.localName;\n            if (!name || uniqueNames[name] !== 1) {\n                return;\n            }\n            if (name === \"length\") {\n                name = \"_length\";\n            }\n            if (values[name] != null) {\n                return;\n            }\n            values[name] = values[index];\n        });\n        return Object.freeze(values);\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"tuple\");\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return unpack(reader, this.coders);\n    }\n}\n//# sourceMappingURL=tuple.js.map"],"names":[],"mappings":";;;;;;;AAOO,MAAM,mBAAmB,MAAM;AAAA,EAElC,YAAY,QAAQ,WAAW;AAC3B,QAAI,UAAU;AACd,UAAM,QAAQ,CAAE;AAChB,WAAO,QAAQ,CAAC,UAAU;AACtB,UAAI,MAAM,SAAS;AACf,kBAAU;AAAA,MAC1B;AACY,YAAM,KAAK,MAAM,IAAI;AAAA,IACjC,CAAS;AACD,UAAM,OAAQ,WAAW,MAAM,KAAK,GAAG,IAAI;AAC3C,UAAM,SAAS,MAAM,WAAW,OAAO;AAX3C;AAYI,qBAAiB,MAAM,EAAE,QAAQ,OAAO,OAAO,OAAO,MAAO,CAAA,GAAG;AAAA,EACxE;AAAA,EACI,eAAe;AACX,UAAM,SAAS,CAAE;AACjB,SAAK,OAAO,QAAQ,CAAC,UAAU;AAC3B,aAAO,KAAK,MAAM,cAAc;AAAA,IAC5C,CAAS;AAED,UAAM,cAAc,KAAK,OAAO,OAAO,CAAC,OAAO,UAAU;AACrD,YAAM,OAAO,MAAM;AACnB,UAAI,MAAM;AACN,YAAI,CAAC,MAAM,IAAI,GAAG;AACd,gBAAM,IAAI,IAAI;AAAA,QAClC;AACgB,cAAM,IAAI;AAAA,MAC1B;AACY,aAAO;AAAA,IACV,GAAE,EAAE;AAEL,SAAK,OAAO,QAAQ,CAAC,OAAO,UAAU;AAClC,UAAI,OAAO,MAAM;AACjB,UAAI,CAAC,QAAQ,YAAY,IAAI,MAAM,GAAG;AAClC;AAAA,MAChB;AACY,UAAI,SAAS,UAAU;AACnB,eAAO;AAAA,MACvB;AACY,UAAI,OAAO,IAAI,KAAK,MAAM;AACtB;AAAA,MAChB;AACY,aAAO,IAAI,IAAI,OAAO,KAAK;AAAA,IACvC,CAAS;AACD,WAAO,OAAO,OAAO,MAAM;AAAA,EACnC;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,UAAM,QAAQ,MAAM,YAAY,QAAQ,OAAO;AAC/C,WAAO,KAAK,QAAQ,KAAK,QAAQ,KAAK;AAAA,EAC9C;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,OAAO,QAAQ,KAAK,MAAM;AAAA,EACzC;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es58.js","sources":["../../node_modules/ethers/lib.esm/abi/abi-coder.js"],"sourcesContent":["/**\n *  When sending values to or receiving values from a [[Contract]], the\n *  data is generally encoded using the [ABI standard](link-solc-abi).\n *\n *  The AbiCoder provides a utility to encode values to ABI data and\n *  decode values from ABI data.\n *\n *  Most of the time, developers should favour the [[Contract]] class,\n *  which further abstracts a lot of the finer details of ABI data.\n *\n *  @_section api/abi/abi-coder:ABI Encoding\n */\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { assertArgumentCount, assertArgument } from \"../utils/index.js\";\nimport { Reader, Writer } from \"./coders/abstract-coder.js\";\nimport { AddressCoder } from \"./coders/address.js\";\nimport { ArrayCoder } from \"./coders/array.js\";\nimport { BooleanCoder } from \"./coders/boolean.js\";\nimport { BytesCoder } from \"./coders/bytes.js\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes.js\";\nimport { NullCoder } from \"./coders/null.js\";\nimport { NumberCoder } from \"./coders/number.js\";\nimport { StringCoder } from \"./coders/string.js\";\nimport { TupleCoder } from \"./coders/tuple.js\";\nimport { ParamType } from \"./fragments.js\";\nimport { getAddress } from \"../address/index.js\";\nimport { getBytes, hexlify, makeError } from \"../utils/index.js\";\n// https://docs.soliditylang.org/en/v0.8.17/control-structures.html\nconst PanicReasons = new Map();\nPanicReasons.set(0x00, \"GENERIC_PANIC\");\nPanicReasons.set(0x01, \"ASSERT_FALSE\");\nPanicReasons.set(0x11, \"OVERFLOW\");\nPanicReasons.set(0x12, \"DIVIDE_BY_ZERO\");\nPanicReasons.set(0x21, \"ENUM_RANGE_ERROR\");\nPanicReasons.set(0x22, \"BAD_STORAGE_DATA\");\nPanicReasons.set(0x31, \"STACK_UNDERFLOW\");\nPanicReasons.set(0x32, \"ARRAY_RANGE_ERROR\");\nPanicReasons.set(0x41, \"OUT_OF_MEMORY\");\nPanicReasons.set(0x51, \"UNINITIALIZED_FUNCTION_CALL\");\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nlet defaultCoder = null;\nlet defaultMaxInflation = 1024;\nfunction getBuiltinCallException(action, tx, data, abiCoder) {\n    let message = \"missing revert data\";\n    let reason = null;\n    const invocation = null;\n    let revert = null;\n    if (data) {\n        message = \"execution reverted\";\n        const bytes = getBytes(data);\n        data = hexlify(data);\n        if (bytes.length === 0) {\n            message += \" (no data present; likely require(false) occurred\";\n            reason = \"require(false)\";\n        }\n        else if (bytes.length % 32 !== 4) {\n            message += \" (could not decode reason; invalid data length)\";\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x08c379a0\") {\n            // Error(string)\n            try {\n                reason = abiCoder.decode([\"string\"], bytes.slice(4))[0];\n                revert = {\n                    signature: \"Error(string)\",\n                    name: \"Error\",\n                    args: [reason]\n                };\n                message += `: ${JSON.stringify(reason)}`;\n            }\n            catch (error) {\n                message += \" (could not decode reason; invalid string data)\";\n            }\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x4e487b71\") {\n            // Panic(uint256)\n            try {\n                const code = Number(abiCoder.decode([\"uint256\"], bytes.slice(4))[0]);\n                revert = {\n                    signature: \"Panic(uint256)\",\n                    name: \"Panic\",\n                    args: [code]\n                };\n                reason = `Panic due to ${PanicReasons.get(code) || \"UNKNOWN\"}(${code})`;\n                message += `: ${reason}`;\n            }\n            catch (error) {\n                message += \" (could not decode panic code)\";\n            }\n        }\n        else {\n            message += \" (unknown custom error)\";\n        }\n    }\n    const transaction = {\n        to: (tx.to ? getAddress(tx.to) : null),\n        data: (tx.data || \"0x\")\n    };\n    if (tx.from) {\n        transaction.from = getAddress(tx.from);\n    }\n    return makeError(message, \"CALL_EXCEPTION\", {\n        action, data, reason, transaction, invocation, revert\n    });\n}\n/**\n *  The **AbiCoder** is a low-level class responsible for encoding JavaScript\n *  values into binary data and decoding binary data into JavaScript values.\n */\nexport class AbiCoder {\n    #getCoder(param) {\n        if (param.isArray()) {\n            return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);\n        }\n        if (param.isTuple()) {\n            return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);\n        }\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, \"invalid \" + match[1] + \" bit length\", \"param\", param);\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            assertArgument(size !== 0 && size <= 32, \"invalid bytes length\", \"param\", param);\n            return new FixedBytesCoder(size, param.name);\n        }\n        assertArgument(false, \"invalid type\", \"type\", param.type);\n    }\n    /**\n     *  Get the default values for the given %%types%%.\n     *\n     *  For example, a ``uint`` is by default ``0`` and ``bool``\n     *  is by default ``false``.\n     */\n    getDefaultValue(types) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.defaultValue();\n    }\n    /**\n     *  Encode the %%values%% as the %%types%% into ABI data.\n     *\n     *  @returns DataHexstring\n     */\n    encode(types, values) {\n        assertArgumentCount(values.length, types.length, \"types/values length mismatch\");\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = (new TupleCoder(coders, \"_\"));\n        const writer = new Writer();\n        coder.encode(writer, values);\n        return writer.data;\n    }\n    /**\n     *  Decode the ABI %%data%% as the %%types%% into values.\n     *\n     *  If %%loose%% decoding is enabled, then strict padding is\n     *  not enforced. Some older versions of Solidity incorrectly\n     *  padded event data emitted from ``external`` functions.\n     */\n    decode(types, data, loose) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.decode(new Reader(data, loose, defaultMaxInflation));\n    }\n    static _setDefaultMaxInflation(value) {\n        assertArgument(typeof (value) === \"number\" && Number.isInteger(value), \"invalid defaultMaxInflation factor\", \"value\", value);\n        defaultMaxInflation = value;\n    }\n    /**\n     *  Returns the shared singleton instance of a default [[AbiCoder]].\n     *\n     *  On the first call, the instance is created internally.\n     */\n    static defaultAbiCoder() {\n        if (defaultCoder == null) {\n            defaultCoder = new AbiCoder();\n        }\n        return defaultCoder;\n    }\n    /**\n     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given\n     *  result %%data%% for the [[CallExceptionAction]] %%action%% against\n     *  the Transaction %%tx%%.\n     */\n    static getBuiltinCallException(action, tx, data) {\n        return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());\n    }\n}\n//# sourceMappingURL=abi-coder.js.map"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AA4BA,MAAM,eAAe,oBAAI,IAAK;AAC9B,aAAa,IAAI,GAAM,eAAe;AACtC,aAAa,IAAI,GAAM,cAAc;AACrC,aAAa,IAAI,IAAM,UAAU;AACjC,aAAa,IAAI,IAAM,gBAAgB;AACvC,aAAa,IAAI,IAAM,kBAAkB;AACzC,aAAa,IAAI,IAAM,kBAAkB;AACzC,aAAa,IAAI,IAAM,iBAAiB;AACxC,aAAa,IAAI,IAAM,mBAAmB;AAC1C,aAAa,IAAI,IAAM,eAAe;AACtC,aAAa,IAAI,IAAM,6BAA6B;AACpD,MAAM,iBAAiB,IAAI,OAAO,iBAAiB;AACnD,MAAM,kBAAkB,IAAI,OAAO,mBAAmB;AACtD,IAAI,eAAe;AACnB,IAAI,sBAAsB;AAC1B,SAAS,wBAAwB,QAAQ,IAAI,MAAM,UAAU;AACzD,MAAI,UAAU;AACd,MAAI,SAAS;AACb,QAAM,aAAa;AACnB,MAAI,SAAS;AACb,MAAI,MAAM;AACN,cAAU;AACV,UAAM,QAAQ,SAAS,IAAI;AAC3B,WAAO,QAAQ,IAAI;AACnB,QAAI,MAAM,WAAW,GAAG;AACpB,iBAAW;AACX,eAAS;AAAA,IACrB,WACiB,MAAM,SAAS,OAAO,GAAG;AAC9B,iBAAW;AAAA,IACvB,WACiB,QAAQ,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,cAAc;AAElD,UAAI;AACA,iBAAS,SAAS,OAAO,CAAC,QAAQ,GAAG,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC;AACtD,iBAAS;AAAA,UACL,WAAW;AAAA,UACX,MAAM;AAAA,UACN,MAAM,CAAC,MAAM;AAAA,QAChB;AACD,mBAAW,KAAK,KAAK,UAAU,MAAM,CAAC;AAAA,MACtD,SACmB,OAAO;AACV,mBAAW;AAAA,MAC3B;AAAA,IACA,WACiB,QAAQ,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,cAAc;AAElD,UAAI;AACA,cAAM,OAAO,OAAO,SAAS,OAAO,CAAC,SAAS,GAAG,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;AACnE,iBAAS;AAAA,UACL,WAAW;AAAA,UACX,MAAM;AAAA,UACN,MAAM,CAAC,IAAI;AAAA,QACd;AACD,iBAAS,gBAAgB,aAAa,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI;AACpE,mBAAW,KAAK,MAAM;AAAA,MACtC,SACmB,OAAO;AACV,mBAAW;AAAA,MAC3B;AAAA,IACA,OACa;AACD,iBAAW;AAAA,IACvB;AAAA,EACA;AACI,QAAM,cAAc;AAAA,IAChB,IAAK,GAAG,KAAK,WAAW,GAAG,EAAE,IAAI;AAAA,IACjC,MAAO,GAAG,QAAQ;AAAA,EACrB;AACD,MAAI,GAAG,MAAM;AACT,gBAAY,OAAO,WAAW,GAAG,IAAI;AAAA,EAC7C;AACI,SAAO,UAAU,SAAS,kBAAkB;AAAA,IACxC;AAAA,IAAQ;AAAA,IAAM;AAAA,IAAQ;AAAA,IAAa;AAAA,IAAY;AAAA,EACvD,CAAK;AACL;AAKO,MAAM,YAAN,MAAM,UAAS;AAAA,EAAf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0CH,gBAAgB,OAAO;AACnB,UAAM,SAAS,MAAM,IAAI,CAAC,SAAS,sBAAK,kCAAL,WAAe,UAAU,KAAK,IAAI,EAAE;AACvE,UAAM,QAAQ,IAAI,WAAW,QAAQ,GAAG;AACxC,WAAO,MAAM,aAAc;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMI,OAAO,OAAO,QAAQ;AAClB,wBAAoB,OAAO,QAAQ,MAAM,QAAQ,8BAA8B;AAC/E,UAAM,SAAS,MAAM,IAAI,CAAC,SAAS,sBAAK,kCAAL,WAAe,UAAU,KAAK,IAAI,EAAE;AACvE,UAAM,QAAS,IAAI,WAAW,QAAQ,GAAG;AACzC,UAAM,SAAS,IAAI,OAAQ;AAC3B,UAAM,OAAO,QAAQ,MAAM;AAC3B,WAAO,OAAO;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQI,OAAO,OAAO,MAAM,OAAO;AACvB,UAAM,SAAS,MAAM,IAAI,CAAC,SAAS,sBAAK,kCAAL,WAAe,UAAU,KAAK,IAAI,EAAE;AACvE,UAAM,QAAQ,IAAI,WAAW,QAAQ,GAAG;AACxC,WAAO,MAAM,OAAO,IAAI,OAAO,MAAM,OAAO,mBAAmB,CAAC;AAAA,EACxE;AAAA,EACI,OAAO,wBAAwB,OAAO;AAClC,mBAAe,OAAQ,UAAW,YAAY,OAAO,UAAU,KAAK,GAAG,sCAAsC,SAAS,KAAK;AAC3H,0BAAsB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMI,OAAO,kBAAkB;AACrB,QAAI,gBAAgB,MAAM;AACtB,qBAAe,IAAI,UAAU;AAAA,IACzC;AACQ,WAAO;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMI,OAAO,wBAAwB,QAAQ,IAAI,MAAM;AAC7C,WAAO,wBAAwB,QAAQ,IAAI,MAAM,UAAS,iBAAiB;AAAA,EACnF;AACA;AA/FO;AACH,cAAS,SAAC,OAAO;AACb,MAAI,MAAM,WAAW;AACjB,WAAO,IAAI,WAAW,sBAAK,kCAAL,WAAe,MAAM,gBAAgB,MAAM,aAAa,MAAM,IAAI;AAAA,EACpG;AACQ,MAAI,MAAM,WAAW;AACjB,WAAO,IAAI,WAAW,MAAM,WAAW,IAAI,CAAC,MAAM,sBAAK,kCAAL,WAAe,EAAE,GAAG,MAAM,IAAI;AAAA,EAC5F;AACQ,UAAQ,MAAM,UAAQ;AAAA,IAClB,KAAK;AACD,aAAO,IAAI,aAAa,MAAM,IAAI;AAAA,IACtC,KAAK;AACD,aAAO,IAAI,aAAa,MAAM,IAAI;AAAA,IACtC,KAAK;AACD,aAAO,IAAI,YAAY,MAAM,IAAI;AAAA,IACrC,KAAK;AACD,aAAO,IAAI,WAAW,MAAM,IAAI;AAAA,IACpC,KAAK;AACD,aAAO,IAAI,UAAU,MAAM,IAAI;AAAA,EAC/C;AAEQ,MAAI,QAAQ,MAAM,KAAK,MAAM,eAAe;AAC5C,MAAI,OAAO;AACP,QAAI,OAAO,SAAS,MAAM,CAAC,KAAK,KAAK;AACrC,mBAAe,SAAS,KAAK,QAAQ,OAAQ,OAAO,MAAO,GAAG,aAAa,MAAM,CAAC,IAAI,eAAe,SAAS,KAAK;AACnH,WAAO,IAAI,YAAY,OAAO,GAAI,MAAM,CAAC,MAAM,OAAQ,MAAM,IAAI;AAAA,EAC7E;AAEQ,UAAQ,MAAM,KAAK,MAAM,cAAc;AACvC,MAAI,OAAO;AACP,QAAI,OAAO,SAAS,MAAM,CAAC,CAAC;AAC5B,mBAAe,SAAS,KAAK,QAAQ,IAAI,wBAAwB,SAAS,KAAK;AAC/E,WAAO,IAAI,gBAAgB,MAAM,MAAM,IAAI;AAAA,EACvD;AACQ,iBAAe,OAAO,gBAAgB,QAAQ,MAAM,IAAI;AAChE;AAnCO,IAAM,WAAN;","x_google_ignoreList":[0]}