@hashgraphonline/standards-sdk 0.0.62 → 0.0.64

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

@@ -1,151 +1,123 @@
-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];
-    }
-    return result;
-  }
-  if (typeof value === "object" && typeof value.toJSON === "function") {
-    return stringify(value.toJSON());
-  }
-  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(", ") + " }";
+var quickFormatUnescaped;
+var hasRequiredQuickFormatUnescaped;
+function requireQuickFormatUnescaped() {
+  if (hasRequiredQuickFormatUnescaped) return quickFormatUnescaped;
+  hasRequiredQuickFormatUnescaped = 1;
+  function tryStringify(o) {
+    try {
+      return JSON.stringify(o);
+    } catch (e) {
+      return '"[Circular]"';
     }
   }
-  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));
+  quickFormatUnescaped = format;
+  function format(f, args, opts) {
+    var ss = opts && opts.stringify || tryStringify;
+    var offset = 1;
+    if (typeof f === "object" && f !== null) {
+      var len = args.length + offset;
+      if (len === 1) return f;
+      var objects = new Array(len);
+      objects[0] = ss(f);
+      for (var index = 1; index < len; index++) {
+        objects[index] = ss(args[index]);
       }
+      return objects.join(" ");
     }
-    details.push(`code=${code}`);
-    details.push(`version=${version}`);
-    if (details.length) {
-      message += " (" + details.join(", ") + ")";
-    }
-  }
-  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 (typeof f !== "string") {
+      return f;
     }
-    ;
-    if (form === "NFD") {
-      const check = String.fromCharCode(233).normalize("NFD");
-      const expected = String.fromCharCode(101, 769);
-      if (check !== expected) {
-        throw new Error("broken");
+    var argLen = args.length;
+    if (argLen === 0) return f;
+    var str = "";
+    var a = 1 - offset;
+    var lastPos = -1;
+    var flen = f && f.length || 0;
+    for (var i = 0; i < flen; ) {
+      if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+        lastPos = lastPos > -1 ? lastPos : 0;
+        switch (f.charCodeAt(i + 1)) {
+          case 100:
+          // 'd'
+          case 102:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Number(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 105:
+            if (a >= argLen)
+              break;
+            if (args[a] == null) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += Math.floor(Number(args[a]));
+            lastPos = i + 2;
+            i++;
+            break;
+          case 79:
+          // 'O'
+          case 111:
+          // 'o'
+          case 106:
+            if (a >= argLen)
+              break;
+            if (args[a] === void 0) break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            var type = typeof args[a];
+            if (type === "string") {
+              str += "'" + args[a] + "'";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            if (type === "function") {
+              str += args[a].name || "<anonymous>";
+              lastPos = i + 2;
+              i++;
+              break;
+            }
+            str += ss(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 115:
+            if (a >= argLen)
+              break;
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += String(args[a]);
+            lastPos = i + 2;
+            i++;
+            break;
+          case 37:
+            if (lastPos < i)
+              str += f.slice(lastPos, i);
+            str += "%";
+            lastPos = i + 2;
+            i++;
+            a--;
+            break;
+        }
+        ++a;
       }
+      ++i;
     }
-    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;
+    if (lastPos === -1)
+      return f;
+    else if (lastPos < flen) {
+      str += f.slice(lastPos);
     }
-    assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
-      operation
-    });
+    return str;
   }
+  return quickFormatUnescaped;
 }
 export {
-  assert,
-  assertArgument,
-  assertArgumentCount,
-  assertPrivate,
-  isError,
-  makeError
+  requireQuickFormatUnescaped as __require
 };
 //# 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/quick-format-unescaped/index.js"],"sourcesContent":["'use strict'\nfunction tryStringify (o) {\n  try { return JSON.stringify(o) } catch(e) { return '\"[Circular]\"' }\n}\n\nmodule.exports = format\n\nfunction format(f, args, opts) {\n  var ss = (opts && opts.stringify) || tryStringify\n  var offset = 1\n  if (typeof f === 'object' && f !== null) {\n    var len = args.length + offset\n    if (len === 1) return f\n    var objects = new Array(len)\n    objects[0] = ss(f)\n    for (var index = 1; index < len; index++) {\n      objects[index] = ss(args[index])\n    }\n    return objects.join(' ')\n  }\n  if (typeof f !== 'string') {\n    return f\n  }\n  var argLen = args.length\n  if (argLen === 0) return f\n  var str = ''\n  var a = 1 - offset\n  var lastPos = -1\n  var flen = (f && f.length) || 0\n  for (var i = 0; i < flen;) {\n    if (f.charCodeAt(i) === 37 && i + 1 < flen) {\n      lastPos = lastPos > -1 ? lastPos : 0\n      switch (f.charCodeAt(i + 1)) {\n        case 100: // 'd'\n        case 102: // 'f'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Number(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 105: // 'i'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Math.floor(Number(args[a]))\n          lastPos = i + 2\n          i++\n          break\n        case 79: // 'O'\n        case 111: // 'o'\n        case 106: // 'j'\n          if (a >= argLen)\n            break\n          if (args[a] === undefined) break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          var type = typeof args[a]\n          if (type === 'string') {\n            str += '\\'' + args[a] + '\\''\n            lastPos = i + 2\n            i++\n            break\n          }\n          if (type === 'function') {\n            str += args[a].name || '<anonymous>'\n            lastPos = i + 2\n            i++\n            break\n          }\n          str += ss(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 115: // 's'\n          if (a >= argLen)\n            break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += String(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 37: // '%'\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += '%'\n          lastPos = i + 2\n          i++\n          a--\n          break\n      }\n      ++a\n    }\n    ++i\n  }\n  if (lastPos === -1)\n    return f\n  else if (lastPos < flen) {\n    str += f.slice(lastPos)\n  }\n\n  return str\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,94 +1,7 @@
-import { assert, assertArgument } from "./standards-sdk.es37.js";
-function _getBytes(value, name, copy) {
-  if (value instanceof Uint8Array) {
-    if (copy) {
-      return new Uint8Array(value);
-    }
-    return value;
-  }
-  if (typeof value === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
-    const result = new Uint8Array((value.length - 2) / 2);
-    let offset = 2;
-    for (let i = 0; i < result.length; i++) {
-      result[i] = parseInt(value.substring(offset, offset + 2), 16);
-      offset += 2;
-    }
-    return result;
-  }
-  assertArgument(false, "invalid BytesLike value", name || "value", value);
-}
-function getBytes(value, name) {
-  return _getBytes(value, name, false);
-}
-function getBytesCopy(value, name) {
-  return _getBytes(value, name, true);
-}
-function isHexString(value, length) {
-  if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-    return false;
-  }
-  if (typeof length === "number" && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  if (length === true && value.length % 2 !== 0) {
-    return false;
-  }
-  return true;
-}
-const HexCharacters = "0123456789abcdef";
-function hexlify(data) {
-  const bytes = getBytes(data);
-  let result = "0x";
-  for (let i = 0; i < bytes.length; i++) {
-    const v = bytes[i];
-    result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
-  }
-  return result;
-}
-function concat(datas) {
-  return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
-}
-function dataSlice(data, start, end) {
-  const bytes = getBytes(data);
-  if (end != null && end > bytes.length) {
-    assert(false, "cannot slice beyond data bounds", "BUFFER_OVERRUN", {
-      buffer: bytes,
-      length: bytes.length,
-      offset: end
-    });
-  }
-  return hexlify(bytes.slice(start == null ? 0 : start, end == null ? bytes.length : end));
-}
-function zeroPad(data, length, left) {
-  const bytes = getBytes(data);
-  assert(length >= bytes.length, "padding exceeds data length", "BUFFER_OVERRUN", {
-    buffer: new Uint8Array(bytes),
-    length,
-    offset: length + 1
-  });
-  const result = new Uint8Array(length);
-  result.fill(0);
-  if (left) {
-    result.set(bytes, length - bytes.length);
-  } else {
-    result.set(bytes, 0);
-  }
-  return hexlify(result);
-}
-function zeroPadValue(data, length) {
-  return zeroPad(data, length, true);
-}
-function zeroPadBytes(data, length) {
-  return zeroPad(data, length, false);
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 export {
-  concat,
-  dataSlice,
-  getBytes,
-  getBytesCopy,
-  hexlify,
-  isHexString,
-  zeroPadBytes,
-  zeroPadValue
+  getDefaultExportFromCjs
 };
 //# sourceMappingURL=standards-sdk.es38.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es38.js","sources":["../../node_modules/ethers/lib.esm/utils/data.js"],"sourcesContent":["/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map"],"names":[],"mappings":";AAOA,SAAS,UAAU,OAAO,MAAM,MAAM;AAClC,MAAI,iBAAiB,YAAY;AAC7B,QAAI,MAAM;AACN,aAAO,IAAI,WAAW,KAAK;AAAA,IACvC;AACQ,WAAO;AAAA,EACf;AACI,MAAI,OAAQ,UAAW,YAAY,MAAM,MAAM,4BAA4B,GAAG;AAC1E,UAAM,SAAS,IAAI,YAAY,MAAM,SAAS,KAAK,CAAC;AACpD,QAAI,SAAS;AACb,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,aAAO,CAAC,IAAI,SAAS,MAAM,UAAU,QAAQ,SAAS,CAAC,GAAG,EAAE;AAC5D,gBAAU;AAAA,IACtB;AACQ,WAAO;AAAA,EACf;AACI,iBAAe,OAAO,2BAA2B,QAAQ,SAAS,KAAK;AAC3E;AAQO,SAAS,SAAS,OAAO,MAAM;AAClC,SAAO,UAAU,OAAO,MAAM,KAAK;AACvC;AAQO,SAAS,aAAa,OAAO,MAAM;AACtC,SAAO,UAAU,OAAO,MAAM,IAAI;AACtC;AAQO,SAAS,YAAY,OAAO,QAAQ;AACvC,MAAI,OAAQ,UAAW,YAAY,CAAC,MAAM,MAAM,kBAAkB,GAAG;AACjE,WAAO;AAAA,EACf;AACI,MAAI,OAAQ,WAAY,YAAY,MAAM,WAAW,IAAI,IAAI,QAAQ;AACjE,WAAO;AAAA,EACf;AACI,MAAI,WAAW,QAAS,MAAM,SAAS,MAAO,GAAG;AAC7C,WAAO;AAAA,EACf;AACI,SAAO;AACX;AAQA,MAAM,gBAAgB;AAIf,SAAS,QAAQ,MAAM;AAC1B,QAAM,QAAQ,SAAS,IAAI;AAC3B,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,UAAM,IAAI,MAAM,CAAC;AACjB,cAAU,eAAe,IAAI,QAAS,CAAC,IAAI,cAAc,IAAI,EAAI;AAAA,EACzE;AACI,SAAO;AACX;AAKO,SAAS,OAAO,OAAO;AAC1B,SAAO,OAAO,MAAM,IAAI,CAAC,MAAM,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE;AACnE;AAgBO,SAAS,UAAU,MAAM,OAAO,KAAK;AACxC,QAAM,QAAQ,SAAS,IAAI;AAC3B,MAAI,OAAO,QAAQ,MAAM,MAAM,QAAQ;AACnC,WAAO,OAAO,mCAAmC,kBAAkB;AAAA,MAC/D,QAAQ;AAAA,MAAO,QAAQ,MAAM;AAAA,MAAQ,QAAQ;AAAA,IACzD,CAAS;AAAA,EACT;AACI,SAAO,QAAQ,MAAM,MAAO,SAAS,OAAQ,IAAI,OAAQ,OAAO,OAAQ,MAAM,SAAS,GAAG,CAAC;AAC/F;AAYA,SAAS,QAAQ,MAAM,QAAQ,MAAM;AACjC,QAAM,QAAQ,SAAS,IAAI;AAC3B,SAAO,UAAU,MAAM,QAAQ,+BAA+B,kBAAkB;AAAA,IAC5E,QAAQ,IAAI,WAAW,KAAK;AAAA,IAC5B;AAAA,IACA,QAAQ,SAAS;AAAA,EACzB,CAAK;AACD,QAAM,SAAS,IAAI,WAAW,MAAM;AACpC,SAAO,KAAK,CAAC;AACb,MAAI,MAAM;AACN,WAAO,IAAI,OAAO,SAAS,MAAM,MAAM;AAAA,EAC/C,OACS;AACD,WAAO,IAAI,OAAO,CAAC;AAAA,EAC3B;AACI,SAAO,QAAQ,MAAM;AACzB;AAWO,SAAS,aAAa,MAAM,QAAQ;AACvC,SAAO,QAAQ,MAAM,QAAQ,IAAI;AACrC;AAWO,SAAS,aAAa,MAAM,QAAQ;AACvC,SAAO,QAAQ,MAAM,QAAQ,KAAK;AACtC;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es38.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}