@hashgraphonline/standards-sdk 0.0.79 → 0.0.81

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

@@ -1,224 +1,162 @@
-import utils from "./standards-sdk.es36.js";
-import parseHeaders from "./standards-sdk.es66.js";
-const $internals = Symbol("internals");
-function normalizeHeader(header) {
-  return header && String(header).trim().toLowerCase();
-}
-function normalizeValue(value) {
-  if (value === false || value == null) {
-    return value;
-  }
-  return utils.isArray(value) ? value.map(normalizeValue) : String(value);
-}
-function parseTokens(str) {
-  const tokens = /* @__PURE__ */ Object.create(null);
-  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-  let match;
-  while (match = tokensRE.exec(str)) {
-    tokens[match[1]] = match[2];
+import { assertArgument, assert } from "./standards-sdk.es46.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 tokens;
+  return value;
 }
-const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
-function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
-  if (utils.isFunction(filter)) {
-    return filter.call(this, value, header);
-  }
-  if (isHeaderNameFilter) {
-    value = header;
-  }
-  if (!utils.isString(value)) return;
-  if (utils.isString(filter)) {
-    return value.indexOf(filter) !== -1;
-  }
-  if (utils.isRegExp(filter)) {
-    return filter.test(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 formatHeader(header) {
-  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
-    return char.toUpperCase() + str;
-  });
+function mask(_value, _bits) {
+  const value = getUint(_value, "value");
+  const bits = BigInt(getNumber(_bits, "bits"));
+  return value & (BN_1 << bits) - BN_1;
 }
-function buildAccessors(obj, header) {
-  const accessorName = utils.toCamelCase(" " + header);
-  ["get", "set", "has"].forEach((methodName) => {
-    Object.defineProperty(obj, methodName + accessorName, {
-      value: function(arg1, arg2, arg3) {
-        return this[methodName].call(this, header, arg1, arg2, arg3);
-      },
-      configurable: true
-    });
-  });
-}
-class AxiosHeaders {
-  constructor(headers) {
-    headers && this.set(headers);
-  }
-  set(header, valueOrRewrite, rewrite) {
-    const self = this;
-    function setHeader(_value, _header, _rewrite) {
-      const lHeader = normalizeHeader(_header);
-      if (!lHeader) {
-        throw new Error("header name must be a non-empty string");
-      }
-      const key = utils.findKey(self, lHeader);
-      if (!key || self[key] === void 0 || _rewrite === true || _rewrite === void 0 && self[key] !== false) {
-        self[key || _header] = normalizeValue(_value);
-      }
-    }
-    const setHeaders = (headers, _rewrite) => utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
-    if (utils.isPlainObject(header) || header instanceof this.constructor) {
-      setHeaders(header, valueOrRewrite);
-    } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
-      setHeaders(parseHeaders(header), valueOrRewrite);
-    } else if (utils.isHeaders(header)) {
-      for (const [key, value] of header.entries()) {
-        setHeader(value, key, rewrite);
-      }
-    } else {
-      header != null && setHeader(valueOrRewrite, header, rewrite);
-    }
-    return this;
-  }
-  get(header, parser) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils.findKey(this, header);
-      if (key) {
-        const value = this[key];
-        if (!parser) {
-          return value;
-        }
-        if (parser === true) {
-          return parseTokens(value);
+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 (utils.isFunction(parser)) {
-          return parser.call(this, value, key);
+        if (value[0] === "-" && value[1] !== "-") {
+          return -BigInt(value.substring(1));
         }
-        if (utils.isRegExp(parser)) {
-          return parser.exec(value);
-        }
-        throw new TypeError("parser must be boolean|regexp|function");
+        return BigInt(value);
+      } catch (e) {
+        assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
       }
-    }
   }
-  has(header, matcher) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils.findKey(this, header);
-      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+  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 false;
+    return BigInt(result);
   }
-  delete(header, matcher) {
-    const self = this;
-    let deleted = false;
-    function deleteHeader(_header) {
-      _header = normalizeHeader(_header);
-      if (_header) {
-        const key = utils.findKey(self, _header);
-        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
-          delete self[key];
-          deleted = true;
+  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);
       }
-    }
-    if (utils.isArray(header)) {
-      header.forEach(deleteHeader);
-    } else {
-      deleteHeader(header);
-    }
-    return deleted;
   }
-  clear(matcher) {
-    const keys = Object.keys(this);
-    let i = keys.length;
-    let deleted = false;
-    while (i--) {
-      const key = keys[i];
-      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
-        delete this[key];
-        deleted = true;
-      }
+  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;
     }
-    return deleted;
-  }
-  normalize(format) {
-    const self = this;
-    const headers = {};
-    utils.forEach(this, (value, header) => {
-      const key = utils.findKey(headers, header);
-      if (key) {
-        self[key] = normalizeValue(value);
-        delete self[header];
-        return;
-      }
-      const normalized = format ? formatHeader(header) : String(header).trim();
-      if (normalized !== header) {
-        delete self[header];
-      }
-      self[normalized] = normalizeValue(value);
-      headers[normalized] = true;
+  } else {
+    const width = getNumber(_width, "width");
+    assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
+      operation: "toBeHex",
+      fault: "overflow",
+      value: _value
     });
-    return this;
-  }
-  concat(...targets) {
-    return this.constructor.concat(this, ...targets);
-  }
-  toJSON(asStrings) {
-    const obj = /* @__PURE__ */ Object.create(null);
-    utils.forEach(this, (value, header) => {
-      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(", ") : value);
-    });
-    return obj;
-  }
-  [Symbol.iterator]() {
-    return Object.entries(this.toJSON())[Symbol.iterator]();
-  }
-  toString() {
-    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
-  }
-  get [Symbol.toStringTag]() {
-    return "AxiosHeaders";
+    while (result.length < width * 2) {
+      result = "0" + result;
+    }
   }
-  static from(thing) {
-    return thing instanceof this ? thing : new this(thing);
+  return "0x" + result;
+}
+function toBeArray(_value) {
+  const value = getUint(_value, "value");
+  if (value === BN_0) {
+    return new Uint8Array([]);
   }
-  static concat(first, ...targets) {
-    const computed = new this(first);
-    targets.forEach((target) => computed.set(target));
-    return computed;
+  let hex = value.toString(16);
+  if (hex.length % 2) {
+    hex = "0" + hex;
   }
-  static accessor(header) {
-    const internals = this[$internals] = this[$internals] = {
-      accessors: {}
-    };
-    const accessors = internals.accessors;
-    const prototype = this.prototype;
-    function defineAccessor(_header) {
-      const lHeader = normalizeHeader(_header);
-      if (!accessors[lHeader]) {
-        buildAccessors(prototype, _header);
-        accessors[lHeader] = true;
-      }
-    }
-    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
-    return this;
+  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;
 }
-AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
-utils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
-  let mapped = key[0].toUpperCase() + key.slice(1);
-  return {
-    get: () => value,
-    set(headerValue) {
-      this[mapped] = headerValue;
-    }
-  };
-});
-utils.freezeMethods(AxiosHeaders);
 export {
-  AxiosHeaders as default
+  fromTwos,
+  getBigInt,
+  getNumber,
+  getUint,
+  mask,
+  toBeArray,
+  toBeHex,
+  toBigInt,
+  toNumber,
+  toTwos
 };
 //# sourceMappingURL=standards-sdk.es50.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es50.js","sources":["../../node_modules/axios/lib/core/AxiosHeaders.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n  return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n  if (value === false || value == null) {\n    return value;\n  }\n\n  return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n  const tokens = Object.create(null);\n  const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n  let match;\n\n  while ((match = tokensRE.exec(str))) {\n    tokens[match[1]] = match[2];\n  }\n\n  return tokens;\n}\n\nconst isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n  if (utils.isFunction(filter)) {\n    return filter.call(this, value, header);\n  }\n\n  if (isHeaderNameFilter) {\n    value = header;\n  }\n\n  if (!utils.isString(value)) return;\n\n  if (utils.isString(filter)) {\n    return value.indexOf(filter) !== -1;\n  }\n\n  if (utils.isRegExp(filter)) {\n    return filter.test(value);\n  }\n}\n\nfunction formatHeader(header) {\n  return header.trim()\n    .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n      return char.toUpperCase() + str;\n    });\n}\n\nfunction buildAccessors(obj, header) {\n  const accessorName = utils.toCamelCase(' ' + header);\n\n  ['get', 'set', 'has'].forEach(methodName => {\n    Object.defineProperty(obj, methodName + accessorName, {\n      value: function(arg1, arg2, arg3) {\n        return this[methodName].call(this, header, arg1, arg2, arg3);\n      },\n      configurable: true\n    });\n  });\n}\n\nclass AxiosHeaders {\n  constructor(headers) {\n    headers && this.set(headers);\n  }\n\n  set(header, valueOrRewrite, rewrite) {\n    const self = this;\n\n    function setHeader(_value, _header, _rewrite) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!lHeader) {\n        throw new Error('header name must be a non-empty string');\n      }\n\n      const key = utils.findKey(self, lHeader);\n\n      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n        self[key || _header] = normalizeValue(_value);\n      }\n    }\n\n    const setHeaders = (headers, _rewrite) =>\n      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n    if (utils.isPlainObject(header) || header instanceof this.constructor) {\n      setHeaders(header, valueOrRewrite)\n    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n      setHeaders(parseHeaders(header), valueOrRewrite);\n    } else if (utils.isHeaders(header)) {\n      for (const [key, value] of header.entries()) {\n        setHeader(value, key, rewrite);\n      }\n    } else {\n      header != null && setHeader(valueOrRewrite, header, rewrite);\n    }\n\n    return this;\n  }\n\n  get(header, parser) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      if (key) {\n        const value = this[key];\n\n        if (!parser) {\n          return value;\n        }\n\n        if (parser === true) {\n          return parseTokens(value);\n        }\n\n        if (utils.isFunction(parser)) {\n          return parser.call(this, value, key);\n        }\n\n        if (utils.isRegExp(parser)) {\n          return parser.exec(value);\n        }\n\n        throw new TypeError('parser must be boolean|regexp|function');\n      }\n    }\n  }\n\n  has(header, matcher) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n    }\n\n    return false;\n  }\n\n  delete(header, matcher) {\n    const self = this;\n    let deleted = false;\n\n    function deleteHeader(_header) {\n      _header = normalizeHeader(_header);\n\n      if (_header) {\n        const key = utils.findKey(self, _header);\n\n        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n          delete self[key];\n\n          deleted = true;\n        }\n      }\n    }\n\n    if (utils.isArray(header)) {\n      header.forEach(deleteHeader);\n    } else {\n      deleteHeader(header);\n    }\n\n    return deleted;\n  }\n\n  clear(matcher) {\n    const keys = Object.keys(this);\n    let i = keys.length;\n    let deleted = false;\n\n    while (i--) {\n      const key = keys[i];\n      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n        delete this[key];\n        deleted = true;\n      }\n    }\n\n    return deleted;\n  }\n\n  normalize(format) {\n    const self = this;\n    const headers = {};\n\n    utils.forEach(this, (value, header) => {\n      const key = utils.findKey(headers, header);\n\n      if (key) {\n        self[key] = normalizeValue(value);\n        delete self[header];\n        return;\n      }\n\n      const normalized = format ? formatHeader(header) : String(header).trim();\n\n      if (normalized !== header) {\n        delete self[header];\n      }\n\n      self[normalized] = normalizeValue(value);\n\n      headers[normalized] = true;\n    });\n\n    return this;\n  }\n\n  concat(...targets) {\n    return this.constructor.concat(this, ...targets);\n  }\n\n  toJSON(asStrings) {\n    const obj = Object.create(null);\n\n    utils.forEach(this, (value, header) => {\n      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n    });\n\n    return obj;\n  }\n\n  [Symbol.iterator]() {\n    return Object.entries(this.toJSON())[Symbol.iterator]();\n  }\n\n  toString() {\n    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'AxiosHeaders';\n  }\n\n  static from(thing) {\n    return thing instanceof this ? thing : new this(thing);\n  }\n\n  static concat(first, ...targets) {\n    const computed = new this(first);\n\n    targets.forEach((target) => computed.set(target));\n\n    return computed;\n  }\n\n  static accessor(header) {\n    const internals = this[$internals] = (this[$internals] = {\n      accessors: {}\n    });\n\n    const accessors = internals.accessors;\n    const prototype = this.prototype;\n\n    function defineAccessor(_header) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!accessors[lHeader]) {\n        buildAccessors(prototype, _header);\n        accessors[lHeader] = true;\n      }\n    }\n\n    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n    return this;\n  }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\n// reserved names hotfix\nutils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {\n  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`\n  return {\n    get: () => value,\n    set(headerValue) {\n      this[mapped] = headerValue;\n    }\n  }\n});\n\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es50.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]}