@hashgraphonline/standards-sdk 0.0.94 → 0.0.95

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

@@ -1,6 +1,162 @@
-const global = globalThis || void 0 || self;
+import { assertArgument, assert } from "./standards-sdk.es49.js";
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const maxValue = 9007199254740991;
+function fromTwos(_value, _width) {
+  const value = getUint(_value, "value");
+  const width = BigInt(getNumber(_width, "width"));
+  assert(value >> width === BN_0, "overflow", "NUMERIC_FAULT", {
+    operation: "fromTwos",
+    fault: "overflow",
+    value: _value
+  });
+  if (value >> width - BN_1) {
+    const mask2 = (BN_1 << width) - BN_1;
+    return -((~value & mask2) + BN_1);
+  }
+  return value;
+}
+function toTwos(_value, _width) {
+  let value = getBigInt(_value, "value");
+  const width = BigInt(getNumber(_width, "width"));
+  const limit = BN_1 << width - BN_1;
+  if (value < BN_0) {
+    value = -value;
+    assert(value <= limit, "too low", "NUMERIC_FAULT", {
+      operation: "toTwos",
+      fault: "overflow",
+      value: _value
+    });
+    const mask2 = (BN_1 << width) - BN_1;
+    return (~value & mask2) + BN_1;
+  } else {
+    assert(value < limit, "too high", "NUMERIC_FAULT", {
+      operation: "toTwos",
+      fault: "overflow",
+      value: _value
+    });
+  }
+  return value;
+}
+function mask(_value, _bits) {
+  const value = getUint(_value, "value");
+  const bits = BigInt(getNumber(_bits, "bits"));
+  return value & (BN_1 << bits) - BN_1;
+}
+function getBigInt(value, name) {
+  switch (typeof value) {
+    case "bigint":
+      return value;
+    case "number":
+      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return BigInt(value);
+    case "string":
+      try {
+        if (value === "") {
+          throw new Error("empty string");
+        }
+        if (value[0] === "-" && value[1] !== "-") {
+          return -BigInt(value.substring(1));
+        }
+        return BigInt(value);
+      } catch (e) {
+        assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
+      }
+  }
+  assertArgument(false, "invalid BigNumberish value", name || "value", value);
+}
+function getUint(value, name) {
+  const result = getBigInt(value, name);
+  assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+    fault: "overflow",
+    operation: "getUint",
+    value
+  });
+  return result;
+}
+const Nibbles = "0123456789abcdef";
+function toBigInt(value) {
+  if (value instanceof Uint8Array) {
+    let result = "0x0";
+    for (const v of value) {
+      result += Nibbles[v >> 4];
+      result += Nibbles[v & 15];
+    }
+    return BigInt(result);
+  }
+  return getBigInt(value);
+}
+function getNumber(value, name) {
+  switch (typeof value) {
+    case "bigint":
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return Number(value);
+    case "number":
+      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return value;
+    case "string":
+      try {
+        if (value === "") {
+          throw new Error("empty string");
+        }
+        return getNumber(BigInt(value), name);
+      } catch (e) {
+        assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
+      }
+  }
+  assertArgument(false, "invalid numeric value", name || "value", value);
+}
+function toNumber(value) {
+  return getNumber(toBigInt(value));
+}
+function toBeHex(_value, _width) {
+  const value = getUint(_value, "value");
+  let result = value.toString(16);
+  if (_width == null) {
+    if (result.length % 2) {
+      result = "0" + result;
+    }
+  } else {
+    const width = getNumber(_width, "width");
+    assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
+      operation: "toBeHex",
+      fault: "overflow",
+      value: _value
+    });
+    while (result.length < width * 2) {
+      result = "0" + result;
+    }
+  }
+  return "0x" + result;
+}
+function toBeArray(_value) {
+  const value = getUint(_value, "value");
+  if (value === BN_0) {
+    return new Uint8Array([]);
+  }
+  let hex = value.toString(16);
+  if (hex.length % 2) {
+    hex = "0" + hex;
+  }
+  const result = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < result.length; i++) {
+    const offset = i * 2;
+    result[i] = parseInt(hex.substring(offset, offset + 2), 16);
+  }
+  return result;
+}
 export {
-  global as default,
-  global
+  fromTwos,
+  getBigInt,
+  getNumber,
+  getUint,
+  mask,
+  toBeArray,
+  toBeHex,
+  toBigInt,
+  toNumber,
+  toTwos
 };
 //# sourceMappingURL=standards-sdk.es54.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es54.js","sources":["../../node_modules/vite-plugin-node-polyfills/shims/global/dist/index.js"],"sourcesContent":["const global = globalThis || void 0 || self;\n\nexport { global as default, global };\n//# sourceMappingURL=index.js.map\n"],"names":[],"mappings":"AAAK,MAAC,SAAS,cAAc,UAAU;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es54.js","sources":["../../node_modules/ethers/lib.esm/utils/maths.js"],"sourcesContent":["/**\n *  Some mathematic operations.\n *\n *  @_subsection: api/utils:Math Helpers  [about-maths]\n */\nimport { hexlify, isBytesLike } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\n//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;\n// IEEE 754 support 53-bits of mantissa\nconst maxValue = 0x1fffffffffffff;\n/**\n *  Convert %%value%% from a twos-compliment representation of %%width%%\n *  bits to its value.\n *\n *  If the highest bit is ``1``, the result will be negative.\n */\nexport function fromTwos(_value, _width) {\n    const value = getUint(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    assert((value >> width) === BN_0, \"overflow\", \"NUMERIC_FAULT\", {\n        operation: \"fromTwos\", fault: \"overflow\", value: _value\n    });\n    // Top bit set; treat as a negative value\n    if (value >> (width - BN_1)) {\n        const mask = (BN_1 << width) - BN_1;\n        return -(((~value) & mask) + BN_1);\n    }\n    return value;\n}\n/**\n *  Convert %%value%% to a twos-compliment representation of\n *  %%width%% bits.\n *\n *  The result will always be positive.\n */\nexport function toTwos(_value, _width) {\n    let value = getBigInt(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    const limit = (BN_1 << (width - BN_1));\n    if (value < BN_0) {\n        value = -value;\n        assert(value <= limit, \"too low\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n        const mask = (BN_1 << width) - BN_1;\n        return ((~value) & mask) + BN_1;\n    }\n    else {\n        assert(value < limit, \"too high\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n    }\n    return value;\n}\n/**\n *  Mask %%value%% with a bitmask of %%bits%% ones.\n */\nexport function mask(_value, _bits) {\n    const value = getUint(_value, \"value\");\n    const bits = BigInt(getNumber(_bits, \"bits\"));\n    return value & ((BN_1 << bits) - BN_1);\n}\n/**\n *  Gets a BigInt from %%value%%. If it is an invalid value for\n *  a BigInt, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getBigInt(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\": return value;\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return BigInt(value);\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                if (value[0] === \"-\" && value[1] !== \"-\") {\n                    return -BigInt(value.substring(1));\n                }\n                return BigInt(value);\n            }\n            catch (e) {\n                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid BigNumberish value\", name || \"value\", value);\n}\n/**\n *  Returns %%value%% as a bigint, validating it is valid as a bigint\n *  value and that it is positive.\n */\nexport function getUint(value, name) {\n    const result = getBigInt(value, name);\n    assert(result >= BN_0, \"unsigned value cannot be negative\", \"NUMERIC_FAULT\", {\n        fault: \"overflow\", operation: \"getUint\", value\n    });\n    return result;\n}\nconst Nibbles = \"0123456789abcdef\";\n/*\n * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it\n * is treated as Big Endian data.\n */\nexport function toBigInt(value) {\n    if (value instanceof Uint8Array) {\n        let result = \"0x0\";\n        for (const v of value) {\n            result += Nibbles[v >> 4];\n            result += Nibbles[v & 0x0f];\n        }\n        return BigInt(result);\n    }\n    return getBigInt(value);\n}\n/**\n *  Gets a //number// from %%value%%. If it is an invalid value for\n *  a //number//, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getNumber(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\":\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return Number(value);\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return value;\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                return getNumber(BigInt(value), name);\n            }\n            catch (e) {\n                assertArgument(false, `invalid numeric string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid numeric value\", name || \"value\", value);\n}\n/**\n *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it\n *  is treated as Big Endian data. Throws if the value is not safe.\n */\nexport function toNumber(value) {\n    return getNumber(toBigInt(value));\n}\n/**\n *  Converts %%value%% to a Big Endian hexstring, optionally padded to\n *  %%width%% bytes.\n */\nexport function toBeHex(_value, _width) {\n    const value = getUint(_value, \"value\");\n    let result = value.toString(16);\n    if (_width == null) {\n        // Ensure the value is of even length\n        if (result.length % 2) {\n            result = \"0\" + result;\n        }\n    }\n    else {\n        const width = getNumber(_width, \"width\");\n        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, \"NUMERIC_FAULT\", {\n            operation: \"toBeHex\",\n            fault: \"overflow\",\n            value: _value\n        });\n        // Pad the value to the required width\n        while (result.length < (width * 2)) {\n            result = \"0\" + result;\n        }\n    }\n    return \"0x\" + result;\n}\n/**\n *  Converts %%value%% to a Big Endian Uint8Array.\n */\nexport function toBeArray(_value) {\n    const value = getUint(_value, \"value\");\n    if (value === BN_0) {\n        return new Uint8Array([]);\n    }\n    let hex = value.toString(16);\n    if (hex.length % 2) {\n        hex = \"0\" + hex;\n    }\n    const result = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < result.length; i++) {\n        const offset = i * 2;\n        result[i] = parseInt(hex.substring(offset, offset + 2), 16);\n    }\n    return result;\n}\n/**\n *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.\n *\n *  A //Quantity// does not have and leading 0 values unless the value is\n *  the literal value `0x0`. This is most commonly used for JSSON-RPC\n *  numeric values.\n */\nexport function toQuantity(value) {\n    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);\n    while (result.startsWith(\"0\")) {\n        result = result.substring(1);\n    }\n    if (result === \"\") {\n        result = \"0\";\n    }\n    return \"0x\" + result;\n}\n//# sourceMappingURL=maths.js.map"],"names":["mask"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,167 +1,26 @@
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var browser = { exports: {} };
-var process = browser.exports = {};
-var cachedSetTimeout;
-var cachedClearTimeout;
-function defaultSetTimout() {
-  throw new Error("setTimeout has not been defined");
-}
-function defaultClearTimeout() {
-  throw new Error("clearTimeout has not been defined");
-}
-(function() {
-  try {
-    if (typeof setTimeout === "function") {
-      cachedSetTimeout = setTimeout;
-    } else {
-      cachedSetTimeout = defaultSetTimout;
-    }
-  } catch (e) {
-    cachedSetTimeout = defaultSetTimout;
-  }
-  try {
-    if (typeof clearTimeout === "function") {
-      cachedClearTimeout = clearTimeout;
-    } else {
-      cachedClearTimeout = defaultClearTimeout;
-    }
-  } catch (e) {
-    cachedClearTimeout = defaultClearTimeout;
-  }
-})();
-function runTimeout(fun) {
-  if (cachedSetTimeout === setTimeout) {
-    return setTimeout(fun, 0);
-  }
-  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-    cachedSetTimeout = setTimeout;
-    return setTimeout(fun, 0);
-  }
-  try {
-    return cachedSetTimeout(fun, 0);
-  } catch (e) {
-    try {
-      return cachedSetTimeout.call(null, fun, 0);
-    } catch (e2) {
-      return cachedSetTimeout.call(this, fun, 0);
-    }
-  }
-}
-function runClearTimeout(marker) {
-  if (cachedClearTimeout === clearTimeout) {
-    return clearTimeout(marker);
-  }
-  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-    cachedClearTimeout = clearTimeout;
-    return clearTimeout(marker);
-  }
-  try {
-    return cachedClearTimeout(marker);
-  } catch (e) {
-    try {
-      return cachedClearTimeout.call(null, marker);
-    } catch (e2) {
-      return cachedClearTimeout.call(this, marker);
-    }
-  }
-}
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
-function cleanUpNextTick() {
-  if (!draining || !currentQueue) {
-    return;
-  }
-  draining = false;
-  if (currentQueue.length) {
-    queue = currentQueue.concat(queue);
-  } else {
-    queueIndex = -1;
-  }
-  if (queue.length) {
-    drainQueue();
-  }
-}
-function drainQueue() {
-  if (draining) {
-    return;
-  }
-  var timeout = runTimeout(cleanUpNextTick);
-  draining = true;
-  var len = queue.length;
-  while (len) {
-    currentQueue = queue;
-    queue = [];
-    while (++queueIndex < len) {
-      if (currentQueue) {
-        currentQueue[queueIndex].run();
-      }
-    }
-    queueIndex = -1;
-    len = queue.length;
-  }
-  currentQueue = null;
-  draining = false;
-  runClearTimeout(timeout);
-}
-process.nextTick = function(fun) {
-  var args = new Array(arguments.length - 1);
-  if (arguments.length > 1) {
-    for (var i = 1; i < arguments.length; i++) {
-      args[i - 1] = arguments[i];
-    }
-  }
-  queue.push(new Item(fun, args));
-  if (queue.length === 1 && !draining) {
-    runTimeout(drainQueue);
-  }
-};
-function Item(fun, array) {
-  this.fun = fun;
-  this.array = array;
-}
-Item.prototype.run = function() {
-  this.fun.apply(null, this.array);
+import { keccak_256 } from "./standards-sdk.es57.js";
+import { getBytes, hexlify } from "./standards-sdk.es50.js";
+let locked = false;
+const _keccak256 = function(data) {
+  return keccak_256(data);
 };
-process.title = "browser";
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = "";
-process.versions = {};
-function noop() {
+let __keccak256 = _keccak256;
+function keccak256(_data) {
+  const data = getBytes(_data, "data");
+  return hexlify(__keccak256(data));
 }
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
-process.listeners = function(name) {
-  return [];
-};
-process.binding = function(name) {
-  throw new Error("process.binding is not supported");
+keccak256._ = _keccak256;
+keccak256.lock = function() {
+  locked = true;
 };
-process.cwd = function() {
-  return "/";
-};
-process.chdir = function(dir) {
-  throw new Error("process.chdir is not supported");
-};
-process.umask = function() {
-  return 0;
+keccak256.register = function(func) {
+  if (locked) {
+    throw new TypeError("keccak256 is locked");
+  }
+  __keccak256 = func;
 };
-var browserExports = browser.exports;
-const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+Object.freeze(keccak256);
 export {
-  process$1 as default,
-  process$1 as process
+  keccak256
 };
 //# sourceMappingURL=standards-sdk.es55.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es55.js","sources":["../../node_modules/vite-plugin-node-polyfills/shims/process/dist/index.js"],"sourcesContent":["function getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nvar browser = {exports: {}};\n\n// shim for using process in browser\nvar process = browser.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ());\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] };\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\nvar browserExports = browser.exports;\nconst process$1 = /*@__PURE__*/getDefaultExportFromCjs(browserExports);\n\nexport { process$1 as default, process$1 as process };\n//# sourceMappingURL=index.js.map\n"],"names":["e"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es55.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]}