@hashgraphonline/standards-sdk 0.0.62 → 0.0.63

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

@@ -1,87 +1,9 @@
-import { keccak256 } from "./standards-sdk.es36.js";
-import { assertArgument } from "./standards-sdk.es37.js";
-import { getBytes } from "./standards-sdk.es38.js";
-const BN_0 = BigInt(0);
-const BN_36 = BigInt(36);
-function getChecksumAddress(address) {
-  address = address.toLowerCase();
-  const chars = address.substring(2).split("");
-  const expanded = new Uint8Array(40);
-  for (let i = 0; i < 40; i++) {
-    expanded[i] = chars[i].charCodeAt(0);
-  }
-  const hashed = getBytes(keccak256(expanded));
-  for (let i = 0; i < 40; i += 2) {
-    if (hashed[i >> 1] >> 4 >= 8) {
-      chars[i] = chars[i].toUpperCase();
-    }
-    if ((hashed[i >> 1] & 15) >= 8) {
-      chars[i + 1] = chars[i + 1].toUpperCase();
-    }
-  }
-  return "0x" + chars.join("");
-}
-const ibanLookup = {};
-for (let i = 0; i < 10; i++) {
-  ibanLookup[String(i)] = String(i);
-}
-for (let i = 0; i < 26; i++) {
-  ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
-}
-const safeDigits = 15;
-function ibanChecksum(address) {
-  address = address.toUpperCase();
-  address = address.substring(4) + address.substring(0, 2) + "00";
-  let expanded = address.split("").map((c) => {
-    return ibanLookup[c];
-  }).join("");
-  while (expanded.length >= safeDigits) {
-    let block = expanded.substring(0, safeDigits);
-    expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
-  }
-  let checksum = String(98 - parseInt(expanded, 10) % 97);
-  while (checksum.length < 2) {
-    checksum = "0" + checksum;
-  }
-  return checksum;
-}
-const Base36 = function() {
-  const result = {};
-  for (let i = 0; i < 36; i++) {
-    const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
-    result[key] = BigInt(i);
-  }
-  return result;
-}();
-function fromBase36(value) {
-  value = value.toLowerCase();
-  let result = BN_0;
-  for (let i = 0; i < value.length; i++) {
-    result = result * BN_36 + Base36[value[i]];
-  }
-  return result;
-}
-function getAddress(address) {
-  assertArgument(typeof address === "string", "invalid address", "address", address);
-  if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
-    if (!address.startsWith("0x")) {
-      address = "0x" + address;
-    }
-    const result = getChecksumAddress(address);
-    assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
-    return result;
-  }
-  if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
-    assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
-    let result = fromBase36(address.substring(4)).toString(16);
-    while (result.length < 40) {
-      result = "0" + result;
-    }
-    return getChecksumAddress("0x" + result);
-  }
-  assertArgument(false, "invalid address", "address", address);
+function bind(fn, thisArg) {
+  return function wrap() {
+    return fn.apply(thisArg, arguments);
+  };
 }
 export {
-  getAddress
+  bind as default
 };
 //# sourceMappingURL=standards-sdk.es35.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es35.js","sources":["../../node_modules/ethers/lib.esm/address/address.js"],"sourcesContent":["import { keccak256 } from \"../crypto/index.js\";\nimport { getBytes, assertArgument } from \"../utils/index.js\";\nconst BN_0 = BigInt(0);\nconst BN_36 = BigInt(36);\nfunction getChecksumAddress(address) {\n    //    if (!isHexString(address, 20)) {\n    //        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    //    }\n    address = address.toLowerCase();\n    const chars = address.substring(2).split(\"\");\n    const expanded = new Uint8Array(40);\n    for (let i = 0; i < 40; i++) {\n        expanded[i] = chars[i].charCodeAt(0);\n    }\n    const hashed = getBytes(keccak256(expanded));\n    for (let i = 0; i < 40; i += 2) {\n        if ((hashed[i >> 1] >> 4) >= 8) {\n            chars[i] = chars[i].toUpperCase();\n        }\n        if ((hashed[i >> 1] & 0x0f) >= 8) {\n            chars[i + 1] = chars[i + 1].toUpperCase();\n        }\n    }\n    return \"0x\" + chars.join(\"\");\n}\n// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number\n// Create lookup table\nconst ibanLookup = {};\nfor (let i = 0; i < 10; i++) {\n    ibanLookup[String(i)] = String(i);\n}\nfor (let i = 0; i < 26; i++) {\n    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);\n}\n// How many decimal digits can we process? (for 64-bit float, this is 15)\n// i.e. Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));\nconst safeDigits = 15;\nfunction ibanChecksum(address) {\n    address = address.toUpperCase();\n    address = address.substring(4) + address.substring(0, 2) + \"00\";\n    let expanded = address.split(\"\").map((c) => { return ibanLookup[c]; }).join(\"\");\n    // Javascript can handle integers safely up to 15 (decimal) digits\n    while (expanded.length >= safeDigits) {\n        let block = expanded.substring(0, safeDigits);\n        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);\n    }\n    let checksum = String(98 - (parseInt(expanded, 10) % 97));\n    while (checksum.length < 2) {\n        checksum = \"0\" + checksum;\n    }\n    return checksum;\n}\n;\nconst Base36 = (function () {\n    ;\n    const result = {};\n    for (let i = 0; i < 36; i++) {\n        const key = \"0123456789abcdefghijklmnopqrstuvwxyz\"[i];\n        result[key] = BigInt(i);\n    }\n    return result;\n})();\nfunction fromBase36(value) {\n    value = value.toLowerCase();\n    let result = BN_0;\n    for (let i = 0; i < value.length; i++) {\n        result = result * BN_36 + Base36[value[i]];\n    }\n    return result;\n}\n/**\n *  Returns a normalized and checksumed address for %%address%%.\n *  This accepts non-checksum addresses, checksum addresses and\n *  [[getIcapAddress]] formats.\n *\n *  The checksum in Ethereum uses the capitalization (upper-case\n *  vs lower-case) of the characters within an address to encode\n *  its checksum, which offers, on average, a checksum of 15-bits.\n *\n *  If %%address%% contains both upper-case and lower-case, it is\n *  assumed to already be a checksum address and its checksum is\n *  validated, and if the address fails its expected checksum an\n *  error is thrown.\n *\n *  If you wish the checksum of %%address%% to be ignore, it should\n *  be converted to lower-case (i.e. ``.toLowercase()``) before\n *  being passed in. This should be a very rare situation though,\n *  that you wish to bypass the safegaurds in place to protect\n *  against an address that has been incorrectly copied from another\n *  source.\n *\n *  @example:\n *    // Adds the checksum (via upper-casing specific letters)\n *    getAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\")\n *    //_result:\n *\n *    // Converts ICAP address and adds checksum\n *    getAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if an address contains mixed case,\n *    // but the checksum fails\n *    getAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_error:\n */\nexport function getAddress(address) {\n    assertArgument(typeof (address) === \"string\", \"invalid address\", \"address\", address);\n    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {\n        // Missing the 0x prefix\n        if (!address.startsWith(\"0x\")) {\n            address = \"0x\" + address;\n        }\n        const result = getChecksumAddress(address);\n        // It is a checksummed address with a bad checksum\n        assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, \"bad address checksum\", \"address\", address);\n        return result;\n    }\n    // Maybe ICAP? (we only support direct mode)\n    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {\n        // It is an ICAP address with a bad checksum\n        assertArgument(address.substring(2, 4) === ibanChecksum(address), \"bad icap checksum\", \"address\", address);\n        let result = fromBase36(address.substring(4)).toString(16);\n        while (result.length < 40) {\n            result = \"0\" + result;\n        }\n        return getChecksumAddress(\"0x\" + result);\n    }\n    assertArgument(false, \"invalid address\", \"address\", address);\n}\n/**\n *  The [ICAP Address format](link-icap) format is an early checksum\n *  format which attempts to be compatible with the banking\n *  industry [IBAN format](link-wiki-iban) for bank accounts.\n *\n *  It is no longer common or a recommended format.\n *\n *  @example:\n *    getIcapAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\");\n *    //_result:\n *\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if the ICAP checksum is wrong\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37\");\n *    //_error:\n */\nexport function getIcapAddress(address) {\n    //let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();\n    let base36 = BigInt(getAddress(address)).toString(36).toUpperCase();\n    while (base36.length < 30) {\n        base36 = \"0\" + base36;\n    }\n    return \"XE\" + ibanChecksum(\"XE00\" + base36) + base36;\n}\n//# sourceMappingURL=address.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es35.js","sources":["../../node_modules/axios/lib/helpers/bind.js"],"sourcesContent":["'use strict';\n\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n"],"names":[],"mappings":"AAEe,SAAS,KAAK,IAAI,SAAS;AACxC,SAAO,SAAS,OAAO;AACrB,WAAO,GAAG,MAAM,SAAS,SAAS;AAAA,EACnC;AACH;","x_google_ignoreList":[0]}

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

@@ -1,26 +1,182 @@
-import { keccak_256 } from "./standards-sdk.es56.js";
-import { getBytes, hexlify } from "./standards-sdk.es38.js";
-let locked = false;
-const _keccak256 = function(data) {
-  return keccak_256(data);
-};
-let __keccak256 = _keccak256;
-function keccak256(_data) {
-  const data = getBytes(_data, "data");
-  return hexlify(__keccak256(data));
+import utils from "./standards-sdk.es34.js";
+import buildURL from "./standards-sdk.es52.js";
+import InterceptorManager from "./standards-sdk.es53.js";
+import dispatchRequest from "./standards-sdk.es54.js";
+import mergeConfig from "./standards-sdk.es37.js";
+import buildFullPath from "./standards-sdk.es55.js";
+import validator from "./standards-sdk.es56.js";
+import AxiosHeaders from "./standards-sdk.es48.js";
+const validators = validator.validators;
+class Axios {
+  constructor(instanceConfig) {
+    this.defaults = instanceConfig;
+    this.interceptors = {
+      request: new InterceptorManager(),
+      response: new InterceptorManager()
+    };
+  }
+  /**
+   * Dispatch a request
+   *
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   *
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  async request(configOrUrl, config) {
+    try {
+      return await this._request(configOrUrl, config);
+    } catch (err) {
+      if (err instanceof Error) {
+        let dummy = {};
+        Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
+        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
+        try {
+          if (!err.stack) {
+            err.stack = stack;
+          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) {
+            err.stack += "\n" + stack;
+          }
+        } catch (e) {
+        }
+      }
+      throw err;
+    }
+  }
+  _request(configOrUrl, config) {
+    if (typeof configOrUrl === "string") {
+      config = config || {};
+      config.url = configOrUrl;
+    } else {
+      config = configOrUrl || {};
+    }
+    config = mergeConfig(this.defaults, config);
+    const { transitional, paramsSerializer, headers } = config;
+    if (transitional !== void 0) {
+      validator.assertOptions(transitional, {
+        silentJSONParsing: validators.transitional(validators.boolean),
+        forcedJSONParsing: validators.transitional(validators.boolean),
+        clarifyTimeoutError: validators.transitional(validators.boolean)
+      }, false);
+    }
+    if (paramsSerializer != null) {
+      if (utils.isFunction(paramsSerializer)) {
+        config.paramsSerializer = {
+          serialize: paramsSerializer
+        };
+      } else {
+        validator.assertOptions(paramsSerializer, {
+          encode: validators.function,
+          serialize: validators.function
+        }, true);
+      }
+    }
+    if (config.allowAbsoluteUrls !== void 0) ;
+    else if (this.defaults.allowAbsoluteUrls !== void 0) {
+      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+    } else {
+      config.allowAbsoluteUrls = true;
+    }
+    validator.assertOptions(config, {
+      baseUrl: validators.spelling("baseURL"),
+      withXsrfToken: validators.spelling("withXSRFToken")
+    }, true);
+    config.method = (config.method || this.defaults.method || "get").toLowerCase();
+    let contextHeaders = headers && utils.merge(
+      headers.common,
+      headers[config.method]
+    );
+    headers && utils.forEach(
+      ["delete", "get", "head", "post", "put", "patch", "common"],
+      (method) => {
+        delete headers[method];
+      }
+    );
+    config.headers = AxiosHeaders.concat(contextHeaders, headers);
+    const requestInterceptorChain = [];
+    let synchronousRequestInterceptors = true;
+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+        return;
+      }
+      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+    });
+    const responseInterceptorChain = [];
+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+    });
+    let promise;
+    let i = 0;
+    let len;
+    if (!synchronousRequestInterceptors) {
+      const chain = [dispatchRequest.bind(this), void 0];
+      chain.unshift.apply(chain, requestInterceptorChain);
+      chain.push.apply(chain, responseInterceptorChain);
+      len = chain.length;
+      promise = Promise.resolve(config);
+      while (i < len) {
+        promise = promise.then(chain[i++], chain[i++]);
+      }
+      return promise;
+    }
+    len = requestInterceptorChain.length;
+    let newConfig = config;
+    i = 0;
+    while (i < len) {
+      const onFulfilled = requestInterceptorChain[i++];
+      const onRejected = requestInterceptorChain[i++];
+      try {
+        newConfig = onFulfilled(newConfig);
+      } catch (error) {
+        onRejected.call(this, error);
+        break;
+      }
+    }
+    try {
+      promise = dispatchRequest.call(this, newConfig);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    i = 0;
+    len = responseInterceptorChain.length;
+    while (i < len) {
+      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+    }
+    return promise;
+  }
+  getUri(config) {
+    config = mergeConfig(this.defaults, config);
+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+    return buildURL(fullPath, config.params, config.paramsSerializer);
+  }
 }
-keccak256._ = _keccak256;
-keccak256.lock = function() {
-  locked = true;
-};
-keccak256.register = function(func) {
-  if (locked) {
-    throw new TypeError("keccak256 is locked");
+utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
+  Axios.prototype[method] = function(url, config) {
+    return this.request(mergeConfig(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  function generateHTTPMethod(isForm) {
+    return function httpMethod(url, data, config) {
+      return this.request(mergeConfig(config || {}, {
+        method,
+        headers: isForm ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url,
+        data
+      }));
+    };
   }
-  __keccak256 = func;
-};
-Object.freeze(keccak256);
+  Axios.prototype[method] = generateHTTPMethod();
+  Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+});
 export {
-  keccak256
+  Axios as default
 };
 //# sourceMappingURL=standards-sdk.es36.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es36.js","sources":["../../node_modules/ethers/lib.esm/crypto/keccak.js"],"sourcesContent":["/**\n *  Cryptographic hashing functions\n *\n *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]\n */\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _keccak256 = function (data) {\n    return keccak_256(data);\n};\nlet __keccak256 = _keccak256;\n/**\n *  Compute the cryptographic KECCAK256 hash of %%data%%.\n *\n *  The %%data%% **must** be a data representation, to compute the\n *  hash of UTF-8 data use the [[id]] function.\n *\n *  @returns DataHexstring\n *  @example:\n *    keccak256(\"0x\")\n *    //_result:\n *\n *    keccak256(\"0x1337\")\n *    //_result:\n *\n *    keccak256(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n *\n *    // Strings are assumed to be DataHexString, otherwise it will\n *    // throw. To hash UTF-8 data, see the note above.\n *    keccak256(\"Hello World\")\n *    //_error:\n */\nexport function keccak256(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__keccak256(data));\n}\nkeccak256._ = _keccak256;\nkeccak256.lock = function () { locked = true; };\nkeccak256.register = function (func) {\n    if (locked) {\n        throw new TypeError(\"keccak256 is locked\");\n    }\n    __keccak256 = func;\n};\nObject.freeze(keccak256);\n//# sourceMappingURL=keccak.js.map"],"names":[],"mappings":";;AAOA,IAAI,SAAS;AACb,MAAM,aAAa,SAAU,MAAM;AAC/B,SAAO,WAAW,IAAI;AAC1B;AACA,IAAI,cAAc;AAuBX,SAAS,UAAU,OAAO;AAC7B,QAAM,OAAO,SAAS,OAAO,MAAM;AACnC,SAAO,QAAQ,YAAY,IAAI,CAAC;AACpC;AACA,UAAU,IAAI;AACd,UAAU,OAAO,WAAY;AAAE,WAAS;AAAO;AAC/C,UAAU,WAAW,SAAU,MAAM;AACjC,MAAI,QAAQ;AACR,UAAM,IAAI,UAAU,qBAAqB;AAAA,EACjD;AACI,gBAAc;AAClB;AACA,OAAO,OAAO,SAAS;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es36.js","sources":["../../node_modules/axios/lib/core/Axios.js"],"sourcesContent":["'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n  constructor(instanceConfig) {\n    this.defaults = instanceConfig;\n    this.interceptors = {\n      request: new InterceptorManager(),\n      response: new InterceptorManager()\n    };\n  }\n\n  /**\n   * Dispatch a request\n   *\n   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n   * @param {?Object} config\n   *\n   * @returns {Promise} The Promise to be fulfilled\n   */\n  async request(configOrUrl, config) {\n    try {\n      return await this._request(configOrUrl, config);\n    } catch (err) {\n      if (err instanceof Error) {\n        let dummy = {};\n\n        Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());\n\n        // slice off the Error: ... line\n        const stack = dummy.stack ? dummy.stack.replace(/^.+\\n/, '') : '';\n        try {\n          if (!err.stack) {\n            err.stack = stack;\n            // match without the 2 top stack lines\n          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\\n.+\\n/, ''))) {\n            err.stack += '\\n' + stack\n          }\n        } catch (e) {\n          // ignore the case where \"stack\" is an un-writable property\n        }\n      }\n\n      throw err;\n    }\n  }\n\n  _request(configOrUrl, config) {\n    /*eslint no-param-reassign:0*/\n    // Allow for axios('example/url'[, config]) a la fetch API\n    if (typeof configOrUrl === 'string') {\n      config = config || {};\n      config.url = configOrUrl;\n    } else {\n      config = configOrUrl || {};\n    }\n\n    config = mergeConfig(this.defaults, config);\n\n    const {transitional, paramsSerializer, headers} = config;\n\n    if (transitional !== undefined) {\n      validator.assertOptions(transitional, {\n        silentJSONParsing: validators.transitional(validators.boolean),\n        forcedJSONParsing: validators.transitional(validators.boolean),\n        clarifyTimeoutError: validators.transitional(validators.boolean)\n      }, false);\n    }\n\n    if (paramsSerializer != null) {\n      if (utils.isFunction(paramsSerializer)) {\n        config.paramsSerializer = {\n          serialize: paramsSerializer\n        }\n      } else {\n        validator.assertOptions(paramsSerializer, {\n          encode: validators.function,\n          serialize: validators.function\n        }, true);\n      }\n    }\n\n    // Set config.allowAbsoluteUrls\n    if (config.allowAbsoluteUrls !== undefined) {\n      // do nothing\n    } else if (this.defaults.allowAbsoluteUrls !== undefined) {\n      config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;\n    } else {\n      config.allowAbsoluteUrls = true;\n    }\n\n    validator.assertOptions(config, {\n      baseUrl: validators.spelling('baseURL'),\n      withXsrfToken: validators.spelling('withXSRFToken')\n    }, true);\n\n    // Set config.method\n    config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n    // Flatten headers\n    let contextHeaders = headers && utils.merge(\n      headers.common,\n      headers[config.method]\n    );\n\n    headers && utils.forEach(\n      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n      (method) => {\n        delete headers[method];\n      }\n    );\n\n    config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n    // filter out skipped interceptors\n    const requestInterceptorChain = [];\n    let synchronousRequestInterceptors = true;\n    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n        return;\n      }\n\n      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    const responseInterceptorChain = [];\n    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    let promise;\n    let i = 0;\n    let len;\n\n    if (!synchronousRequestInterceptors) {\n      const chain = [dispatchRequest.bind(this), undefined];\n      chain.unshift.apply(chain, requestInterceptorChain);\n      chain.push.apply(chain, responseInterceptorChain);\n      len = chain.length;\n\n      promise = Promise.resolve(config);\n\n      while (i < len) {\n        promise = promise.then(chain[i++], chain[i++]);\n      }\n\n      return promise;\n    }\n\n    len = requestInterceptorChain.length;\n\n    let newConfig = config;\n\n    i = 0;\n\n    while (i < len) {\n      const onFulfilled = requestInterceptorChain[i++];\n      const onRejected = requestInterceptorChain[i++];\n      try {\n        newConfig = onFulfilled(newConfig);\n      } catch (error) {\n        onRejected.call(this, error);\n        break;\n      }\n    }\n\n    try {\n      promise = dispatchRequest.call(this, newConfig);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n\n    i = 0;\n    len = responseInterceptorChain.length;\n\n    while (i < len) {\n      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n    }\n\n    return promise;\n  }\n\n  getUri(config) {\n    config = mergeConfig(this.defaults, config);\n    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);\n    return buildURL(fullPath, config.params, config.paramsSerializer);\n  }\n}\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method,\n      url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url,\n        data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,151 +1,84 @@
-import { version } from "./standards-sdk.es34.js";
-import { defineProperties } from "./standards-sdk.es51.js";
-function stringify(value) {
-  if (value == null) {
-    return "null";
-  }
-  if (Array.isArray(value)) {
-    return "[ " + value.map(stringify).join(", ") + " ]";
-  }
-  if (value instanceof Uint8Array) {
-    const HEX = "0123456789abcdef";
-    let result = "0x";
-    for (let i = 0; i < value.length; i++) {
-      result += HEX[value[i] >> 4];
-      result += HEX[value[i] & 15];
+import utils from "./standards-sdk.es34.js";
+import AxiosHeaders from "./standards-sdk.es48.js";
+const headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;
+function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  const config = {};
+  function getMergedValue(target, source, prop, caseless) {
+    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+      return utils.merge.call({ caseless }, target, source);
+    } else if (utils.isPlainObject(source)) {
+      return utils.merge({}, source);
+    } else if (utils.isArray(source)) {
+      return source.slice();
     }
-    return result;
-  }
-  if (typeof value === "object" && typeof value.toJSON === "function") {
-    return stringify(value.toJSON());
+    return source;
   }
-  switch (typeof value) {
-    case "boolean":
-    case "symbol":
-      return value.toString();
-    case "bigint":
-      return BigInt(value).toString();
-    case "number":
-      return value.toString();
-    case "string":
-      return JSON.stringify(value);
-    case "object": {
-      const keys = Object.keys(value);
-      keys.sort();
-      return "{ " + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(", ") + " }";
+  function mergeDeepProperties(a, b, prop, caseless) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(a, b, prop, caseless);
+    } else if (!utils.isUndefined(a)) {
+      return getMergedValue(void 0, a, prop, caseless);
     }
   }
-  return `[ COULD NOT SERIALIZE ]`;
-}
-function isError(error, code) {
-  return error && error.code === code;
-}
-function makeError(message, code, info) {
-  let shortMessage = message;
-  {
-    const details = [];
-    if (info) {
-      if ("message" in info || "code" in info || "name" in info) {
-        throw new Error(`value will overwrite populated values: ${stringify(info)}`);
-      }
-      for (const key in info) {
-        if (key === "shortMessage") {
-          continue;
-        }
-        const value = info[key];
-        details.push(key + "=" + stringify(value));
-      }
-    }
-    details.push(`code=${code}`);
-    details.push(`version=${version}`);
-    if (details.length) {
-      message += " (" + details.join(", ") + ")";
+  function valueFromConfig2(a, b) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(void 0, b);
     }
   }
-  let error;
-  switch (code) {
-    case "INVALID_ARGUMENT":
-      error = new TypeError(message);
-      break;
-    case "NUMERIC_FAULT":
-    case "BUFFER_OVERRUN":
-      error = new RangeError(message);
-      break;
-    default:
-      error = new Error(message);
-  }
-  defineProperties(error, { code });
-  if (info) {
-    Object.assign(error, info);
-  }
-  if (error.shortMessage == null) {
-    defineProperties(error, { shortMessage });
-  }
-  return error;
-}
-function assert(check, message, code, info) {
-  if (!check) {
-    throw makeError(message, code, info);
-  }
-}
-function assertArgument(check, message, name, value) {
-  assert(check, message, "INVALID_ARGUMENT", { argument: name, value });
-}
-function assertArgumentCount(count, expectedCount, message) {
-  if (message == null) {
-    message = "";
-  }
-  if (message) {
-    message = ": " + message;
-  }
-  assert(count >= expectedCount, "missing argument" + message, "MISSING_ARGUMENT", {
-    count,
-    expectedCount
-  });
-  assert(count <= expectedCount, "too many arguments" + message, "UNEXPECTED_ARGUMENT", {
-    count,
-    expectedCount
-  });
-}
-["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => {
-  try {
-    if ("test".normalize(form) !== "test") {
-      throw new Error("bad");
-    }
-    ;
-    if (form === "NFD") {
-      const check = String.fromCharCode(233).normalize("NFD");
-      const expected = String.fromCharCode(101, 769);
-      if (check !== expected) {
-        throw new Error("broken");
-      }
+  function defaultToConfig2(a, b) {
+    if (!utils.isUndefined(b)) {
+      return getMergedValue(void 0, b);
+    } else if (!utils.isUndefined(a)) {
+      return getMergedValue(void 0, a);
     }
-    accum.push(form);
-  } catch (error) {
   }
-  return accum;
-}, []);
-function assertPrivate(givenGuard, guard, className) {
-  if (className == null) {
-    className = "";
-  }
-  if (givenGuard !== guard) {
-    let method = className, operation = "new";
-    if (className) {
-      method += ".";
-      operation += " " + className;
+  function mergeDirectKeys(a, b, prop) {
+    if (prop in config2) {
+      return getMergedValue(a, b);
+    } else if (prop in config1) {
+      return getMergedValue(void 0, a);
     }
-    assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
-      operation
-    });
   }
+  const mergeMap = {
+    url: valueFromConfig2,
+    method: valueFromConfig2,
+    data: valueFromConfig2,
+    baseURL: defaultToConfig2,
+    transformRequest: defaultToConfig2,
+    transformResponse: defaultToConfig2,
+    paramsSerializer: defaultToConfig2,
+    timeout: defaultToConfig2,
+    timeoutMessage: defaultToConfig2,
+    withCredentials: defaultToConfig2,
+    withXSRFToken: defaultToConfig2,
+    adapter: defaultToConfig2,
+    responseType: defaultToConfig2,
+    xsrfCookieName: defaultToConfig2,
+    xsrfHeaderName: defaultToConfig2,
+    onUploadProgress: defaultToConfig2,
+    onDownloadProgress: defaultToConfig2,
+    decompress: defaultToConfig2,
+    maxContentLength: defaultToConfig2,
+    maxBodyLength: defaultToConfig2,
+    beforeRedirect: defaultToConfig2,
+    transport: defaultToConfig2,
+    httpAgent: defaultToConfig2,
+    httpsAgent: defaultToConfig2,
+    cancelToken: defaultToConfig2,
+    socketPath: defaultToConfig2,
+    responseEncoding: defaultToConfig2,
+    validateStatus: mergeDirectKeys,
+    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
+  };
+  utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
+    const merge = mergeMap[prop] || mergeDeepProperties;
+    const configValue = merge(config1[prop], config2[prop], prop);
+    utils.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
 }
 export {
-  assert,
-  assertArgument,
-  assertArgumentCount,
-  assertPrivate,
-  isError,
-  makeError
+  mergeConfig as default
 };
 //# sourceMappingURL=standards-sdk.es37.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es37.js","sources":["../../node_modules/ethers/lib.esm/utils/errors.js"],"sourcesContent":["/**\n *  All errors in ethers include properties to ensure they are both\n *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).\n *\n *  The [[isError]] function can be used to check the error ``code`` and\n *  provide a type guard for the properties present on that error interface.\n *\n *  @_section: api/utils/errors:Errors  [about-errors]\n */\nimport { version } from \"../_version.js\";\nimport { defineProperties } from \"./properties.js\";\nfunction stringify(value) {\n    if (value == null) {\n        return \"null\";\n    }\n    if (Array.isArray(value)) {\n        return \"[ \" + (value.map(stringify)).join(\", \") + \" ]\";\n    }\n    if (value instanceof Uint8Array) {\n        const HEX = \"0123456789abcdef\";\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            result += HEX[value[i] >> 4];\n            result += HEX[value[i] & 0xf];\n        }\n        return result;\n    }\n    if (typeof (value) === \"object\" && typeof (value.toJSON) === \"function\") {\n        return stringify(value.toJSON());\n    }\n    switch (typeof (value)) {\n        case \"boolean\":\n        case \"symbol\":\n            return value.toString();\n        case \"bigint\":\n            return BigInt(value).toString();\n        case \"number\":\n            return (value).toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"object\": {\n            const keys = Object.keys(value);\n            keys.sort();\n            return \"{ \" + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(\", \") + \" }\";\n        }\n    }\n    return `[ COULD NOT SERIALIZE ]`;\n}\n/**\n *  Returns true if the %%error%% matches an error thrown by ethers\n *  that matches the error %%code%%.\n *\n *  In TypeScript environments, this can be used to check that %%error%%\n *  matches an EthersError type, which means the expected properties will\n *  be set.\n *\n *  @See [ErrorCodes](api:ErrorCode)\n *  @example\n *    try {\n *      // code....\n *    } catch (e) {\n *      if (isError(e, \"CALL_EXCEPTION\")) {\n *          // The Type Guard has validated this object\n *          console.log(e.data);\n *      }\n *    }\n */\nexport function isError(error, code) {\n    return (error && error.code === code);\n}\n/**\n *  Returns true if %%error%% is a [[CallExceptionError].\n */\nexport function isCallException(error) {\n    return isError(error, \"CALL_EXCEPTION\");\n}\n/**\n *  Returns a new Error configured to the format ethers emits errors, with\n *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties\n *  for the corresponding EthersError.\n *\n *  Each error in ethers includes the version of ethers, a\n *  machine-readable [[ErrorCode]], and depending on %%code%%, additional\n *  required properties. The error message will also include the %%message%%,\n *  ethers version, %%code%% and all additional properties, serialized.\n */\nexport function makeError(message, code, info) {\n    let shortMessage = message;\n    {\n        const details = [];\n        if (info) {\n            if (\"message\" in info || \"code\" in info || \"name\" in info) {\n                throw new Error(`value will overwrite populated values: ${stringify(info)}`);\n            }\n            for (const key in info) {\n                if (key === \"shortMessage\") {\n                    continue;\n                }\n                const value = (info[key]);\n                //                try {\n                details.push(key + \"=\" + stringify(value));\n                //                } catch (error: any) {\n                //                console.log(\"MMM\", error.message);\n                //                    details.push(key + \"=[could not serialize object]\");\n                //                }\n            }\n        }\n        details.push(`code=${code}`);\n        details.push(`version=${version}`);\n        if (details.length) {\n            message += \" (\" + details.join(\", \") + \")\";\n        }\n    }\n    let error;\n    switch (code) {\n        case \"INVALID_ARGUMENT\":\n            error = new TypeError(message);\n            break;\n        case \"NUMERIC_FAULT\":\n        case \"BUFFER_OVERRUN\":\n            error = new RangeError(message);\n            break;\n        default:\n            error = new Error(message);\n    }\n    defineProperties(error, { code });\n    if (info) {\n        Object.assign(error, info);\n    }\n    if (error.shortMessage == null) {\n        defineProperties(error, { shortMessage });\n    }\n    return error;\n}\n/**\n *  Throws an EthersError with %%message%%, %%code%% and additional error\n *  %%info%% when %%check%% is falsish..\n *\n *  @see [[api:makeError]]\n */\nexport function assert(check, message, code, info) {\n    if (!check) {\n        throw makeError(message, code, info);\n    }\n}\n/**\n *  A simple helper to simply ensuring provided arguments match expected\n *  constraints, throwing if not.\n *\n *  In TypeScript environments, the %%check%% has been asserted true, so\n *  any further code does not need additional compile-time checks.\n */\nexport function assertArgument(check, message, name, value) {\n    assert(check, message, \"INVALID_ARGUMENT\", { argument: name, value: value });\n}\nexport function assertArgumentCount(count, expectedCount, message) {\n    if (message == null) {\n        message = \"\";\n    }\n    if (message) {\n        message = \": \" + message;\n    }\n    assert(count >= expectedCount, \"missing argument\" + message, \"MISSING_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n    assert(count <= expectedCount, \"too many arguments\" + message, \"UNEXPECTED_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n}\nconst _normalizeForms = [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].reduce((accum, form) => {\n    try {\n        // General test for normalize\n        /* c8 ignore start */\n        if (\"test\".normalize(form) !== \"test\") {\n            throw new Error(\"bad\");\n        }\n        ;\n        /* c8 ignore stop */\n        if (form === \"NFD\") {\n            const check = String.fromCharCode(0xe9).normalize(\"NFD\");\n            const expected = String.fromCharCode(0x65, 0x0301);\n            /* c8 ignore start */\n            if (check !== expected) {\n                throw new Error(\"broken\");\n            }\n            /* c8 ignore stop */\n        }\n        accum.push(form);\n    }\n    catch (error) { }\n    return accum;\n}, []);\n/**\n *  Throws if the normalization %%form%% is not supported.\n */\nexport function assertNormalize(form) {\n    assert(_normalizeForms.indexOf(form) >= 0, \"platform missing String.prototype.normalize\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"String.prototype.normalize\", info: { form }\n    });\n}\n/**\n *  Many classes use file-scoped values to guard the constructor,\n *  making it effectively private. This facilitates that pattern\n *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,\n *  throwing if not, indicating the %%className%% if provided.\n */\nexport function assertPrivate(givenGuard, guard, className) {\n    if (className == null) {\n        className = \"\";\n    }\n    if (givenGuard !== guard) {\n        let method = className, operation = \"new\";\n        if (className) {\n            method += \".\";\n            operation += \" \" + className;\n        }\n        assert(false, `private constructor; use ${method}from* methods`, \"UNSUPPORTED_OPERATION\", {\n            operation\n        });\n    }\n}\n//# sourceMappingURL=errors.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es37.js","sources":["../../node_modules/axios/lib/core/mergeConfig.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  const config = {};\n\n  function getMergedValue(target, source, prop, caseless) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge.call({caseless}, target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(a, b, prop , caseless) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(a, b, prop , caseless);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a, prop , caseless);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(a, b, prop) {\n    if (prop in config2) {\n      return getMergedValue(a, b);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  const mergeMap = {\n    url: valueFromConfig2,\n    method: valueFromConfig2,\n    data: valueFromConfig2,\n    baseURL: defaultToConfig2,\n    transformRequest: defaultToConfig2,\n    transformResponse: defaultToConfig2,\n    paramsSerializer: defaultToConfig2,\n    timeout: defaultToConfig2,\n    timeoutMessage: defaultToConfig2,\n    withCredentials: defaultToConfig2,\n    withXSRFToken: defaultToConfig2,\n    adapter: defaultToConfig2,\n    responseType: defaultToConfig2,\n    xsrfCookieName: defaultToConfig2,\n    xsrfHeaderName: defaultToConfig2,\n    onUploadProgress: defaultToConfig2,\n    onDownloadProgress: defaultToConfig2,\n    decompress: defaultToConfig2,\n    maxContentLength: defaultToConfig2,\n    maxBodyLength: defaultToConfig2,\n    beforeRedirect: defaultToConfig2,\n    transport: defaultToConfig2,\n    httpAgent: defaultToConfig2,\n    httpsAgent: defaultToConfig2,\n    cancelToken: defaultToConfig2,\n    socketPath: defaultToConfig2,\n    responseEncoding: defaultToConfig2,\n    validateStatus: mergeDirectKeys,\n    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)\n  };\n\n  utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {\n    const merge = mergeMap[prop] || mergeDeepProperties;\n    const configValue = merge(config1[prop], config2[prop], prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n}\n"],"names":[],"mappings":";;AAKA,MAAM,kBAAkB,CAAC,UAAU,iBAAiB,eAAe,EAAE,GAAG,MAAK,IAAK;AAWnE,SAAS,YAAY,SAAS,SAAS;AAEpD,YAAU,WAAW,CAAE;AACvB,QAAM,SAAS,CAAE;AAEjB,WAAS,eAAe,QAAQ,QAAQ,MAAM,UAAU;AACtD,QAAI,MAAM,cAAc,MAAM,KAAK,MAAM,cAAc,MAAM,GAAG;AAC9D,aAAO,MAAM,MAAM,KAAK,EAAC,SAAQ,GAAG,QAAQ,MAAM;AAAA,IACnD,WAAU,MAAM,cAAc,MAAM,GAAG;AACtC,aAAO,MAAM,MAAM,CAAE,GAAE,MAAM;AAAA,IAC9B,WAAU,MAAM,QAAQ,MAAM,GAAG;AAChC,aAAO,OAAO,MAAO;AAAA,IAC3B;AACI,WAAO;AAAA,EACX;AAGE,WAAS,oBAAoB,GAAG,GAAG,MAAO,UAAU;AAClD,QAAI,CAAC,MAAM,YAAY,CAAC,GAAG;AACzB,aAAO,eAAe,GAAG,GAAG,MAAO,QAAQ;AAAA,IAC5C,WAAU,CAAC,MAAM,YAAY,CAAC,GAAG;AAChC,aAAO,eAAe,QAAW,GAAG,MAAO,QAAQ;AAAA,IACzD;AAAA,EACA;AAGE,WAAS,iBAAiB,GAAG,GAAG;AAC9B,QAAI,CAAC,MAAM,YAAY,CAAC,GAAG;AACzB,aAAO,eAAe,QAAW,CAAC;AAAA,IACxC;AAAA,EACA;AAGE,WAAS,iBAAiB,GAAG,GAAG;AAC9B,QAAI,CAAC,MAAM,YAAY,CAAC,GAAG;AACzB,aAAO,eAAe,QAAW,CAAC;AAAA,IACnC,WAAU,CAAC,MAAM,YAAY,CAAC,GAAG;AAChC,aAAO,eAAe,QAAW,CAAC;AAAA,IACxC;AAAA,EACA;AAGE,WAAS,gBAAgB,GAAG,GAAG,MAAM;AACnC,QAAI,QAAQ,SAAS;AACnB,aAAO,eAAe,GAAG,CAAC;AAAA,IAChC,WAAe,QAAQ,SAAS;AAC1B,aAAO,eAAe,QAAW,CAAC;AAAA,IACxC;AAAA,EACA;AAEE,QAAM,WAAW;AAAA,IACf,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA,IACT,kBAAkB;AAAA,IAClB,mBAAmB;AAAA,IACnB,kBAAkB;AAAA,IAClB,SAAS;AAAA,IACT,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,oBAAoB;AAAA,IACpB,YAAY;AAAA,IACZ,kBAAkB;AAAA,IAClB,eAAe;AAAA,IACf,gBAAgB;AAAA,IAChB,WAAW;AAAA,IACX,WAAW;AAAA,IACX,YAAY;AAAA,IACZ,aAAa;AAAA,IACb,YAAY;AAAA,IACZ,kBAAkB;AAAA,IAClB,gBAAgB;AAAA,IAChB,SAAS,CAAC,GAAG,GAAI,SAAS,oBAAoB,gBAAgB,CAAC,GAAG,gBAAgB,CAAC,GAAE,MAAM,IAAI;AAAA,EAChG;AAED,QAAM,QAAQ,OAAO,KAAK,OAAO,OAAO,IAAI,SAAS,OAAO,CAAC,GAAG,SAAS,mBAAmB,MAAM;AAChG,UAAM,QAAQ,SAAS,IAAI,KAAK;AAChC,UAAM,cAAc,MAAM,QAAQ,IAAI,GAAG,QAAQ,IAAI,GAAG,IAAI;AAC5D,IAAC,MAAM,YAAY,WAAW,KAAK,UAAU,oBAAqB,OAAO,IAAI,IAAI;AAAA,EACrF,CAAG;AAED,SAAO;AACT;","x_google_ignoreList":[0]}