@hashgraphonline/standards-sdk 0.0.105 → 0.0.106

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es62.js","sources":["../../node_modules/path-browserify/index.js"],"sourcesContent":["// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n"],"names":["process"],"mappings":";;;;;;AA0BA,WAAS,WAAW,MAAM;AACxB,QAAI,OAAO,SAAS,UAAU;AAC5B,YAAM,IAAI,UAAU,qCAAqC,KAAK,UAAU,IAAI,CAAC;AAAA,IACjF;AAAA,EACA;AAGA,WAAS,qBAAqB,MAAM,gBAAgB;AAClD,QAAI,MAAM;AACV,QAAI,oBAAoB;AACxB,QAAI,YAAY;AAChB,QAAI,OAAO;AACX,QAAI;AACJ,aAAS,IAAI,GAAG,KAAK,KAAK,QAAQ,EAAE,GAAG;AACrC,UAAI,IAAI,KAAK;AACX,eAAO,KAAK,WAAW,CAAC;AAAA,eACjB,SAAS;AAChB;AAAA;AAEA,eAAO;AACT,UAAI,SAAS,IAAU;AACrB,YAAI,cAAc,IAAI,KAAK,SAAS,EAAG;AAAA,iBAE5B,cAAc,IAAI,KAAK,SAAS,GAAG;AAC5C,cAAI,IAAI,SAAS,KAAK,sBAAsB,KAAK,IAAI,WAAW,IAAI,SAAS,CAAC,MAAM,MAAY,IAAI,WAAW,IAAI,SAAS,CAAC,MAAM,IAAU;AAC3I,gBAAI,IAAI,SAAS,GAAG;AAClB,kBAAI,iBAAiB,IAAI,YAAY,GAAG;AACxC,kBAAI,mBAAmB,IAAI,SAAS,GAAG;AACrC,oBAAI,mBAAmB,IAAI;AACzB,wBAAM;AACN,sCAAoB;AAAA,gBACpC,OAAqB;AACL,wBAAM,IAAI,MAAM,GAAG,cAAc;AACjC,sCAAoB,IAAI,SAAS,IAAI,IAAI,YAAY,GAAG;AAAA,gBACxE;AACc,4BAAY;AACZ,uBAAO;AACP;AAAA,cACd;AAAA,YACA,WAAqB,IAAI,WAAW,KAAK,IAAI,WAAW,GAAG;AAC/C,oBAAM;AACN,kCAAoB;AACpB,0BAAY;AACZ,qBAAO;AACP;AAAA,YACZ;AAAA,UACA;AACQ,cAAI,gBAAgB;AAClB,gBAAI,IAAI,SAAS;AACf,qBAAO;AAAA;AAEP,oBAAM;AACR,gCAAoB;AAAA,UAC9B;AAAA,QACA,OAAa;AACL,cAAI,IAAI,SAAS;AACf,mBAAO,MAAM,KAAK,MAAM,YAAY,GAAG,CAAC;AAAA;AAExC,kBAAM,KAAK,MAAM,YAAY,GAAG,CAAC;AACnC,8BAAoB,IAAI,YAAY;AAAA,QAC5C;AACM,oBAAY;AACZ,eAAO;AAAA,MACR,WAAU,SAAS,MAAY,SAAS,IAAI;AAC3C,UAAE;AAAA,MACR,OAAW;AACL,eAAO;AAAA,MACb;AAAA,IACA;AACE,WAAO;AAAA,EACT;AAEA,WAAS,QAAQ,KAAK,YAAY;AAChC,QAAI,MAAM,WAAW,OAAO,WAAW;AACvC,QAAI,OAAO,WAAW,SAAS,WAAW,QAAQ,OAAO,WAAW,OAAO;AAC3E,QAAI,CAAC,KAAK;AACR,aAAO;AAAA,IACX;AACE,QAAI,QAAQ,WAAW,MAAM;AAC3B,aAAO,MAAM;AAAA,IACjB;AACE,WAAO,MAAM,MAAM;AAAA,EACrB;AAEA,MAAI,QAAQ;AAAA;AAAA,IAEV,SAAS,SAAS,UAAU;AAC1B,UAAI,eAAe;AACnB,UAAI,mBAAmB;AACvB,UAAI;AAEJ,eAAS,IAAI,UAAU,SAAS,GAAG,KAAK,MAAM,CAAC,kBAAkB,KAAK;AACpE,YAAI;AACJ,YAAI,KAAK;AACP,iBAAO,UAAU,CAAC;AAAA,aACf;AACH,cAAI,QAAQ;AACV,kBAAMA,UAAQ,IAAK;AACrB,iBAAO;AAAA,QACf;AAEM,mBAAW,IAAI;AAGf,YAAI,KAAK,WAAW,GAAG;AACrB;AAAA,QACR;AAEM,uBAAe,OAAO,MAAM;AAC5B,2BAAmB,KAAK,WAAW,CAAC,MAAM;AAAA,MAChD;AAMI,qBAAe,qBAAqB,cAAc,CAAC,gBAAgB;AAEnE,UAAI,kBAAkB;AACpB,YAAI,aAAa,SAAS;AACxB,iBAAO,MAAM;AAAA;AAEb,iBAAO;AAAA,MACf,WAAe,aAAa,SAAS,GAAG;AAClC,eAAO;AAAA,MACb,OAAW;AACL,eAAO;AAAA,MACb;AAAA,IACG;AAAA,IAED,WAAW,SAAS,UAAU,MAAM;AAClC,iBAAW,IAAI;AAEf,UAAI,KAAK,WAAW,EAAG,QAAO;AAE9B,UAAI,aAAa,KAAK,WAAW,CAAC,MAAM;AACxC,UAAI,oBAAoB,KAAK,WAAW,KAAK,SAAS,CAAC,MAAM;AAG7D,aAAO,qBAAqB,MAAM,CAAC,UAAU;AAE7C,UAAI,KAAK,WAAW,KAAK,CAAC,WAAY,QAAO;AAC7C,UAAI,KAAK,SAAS,KAAK,kBAAmB,SAAQ;AAElD,UAAI,WAAY,QAAO,MAAM;AAC7B,aAAO;AAAA,IACR;AAAA,IAED,YAAY,SAAS,WAAW,MAAM;AACpC,iBAAW,IAAI;AACf,aAAO,KAAK,SAAS,KAAK,KAAK,WAAW,CAAC,MAAM;AAAA,IAClD;AAAA,IAED,MAAM,SAAS,OAAO;AACpB,UAAI,UAAU,WAAW;AACvB,eAAO;AACT,UAAI;AACJ,eAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,EAAE,GAAG;AACzC,YAAI,MAAM,UAAU,CAAC;AACrB,mBAAW,GAAG;AACd,YAAI,IAAI,SAAS,GAAG;AAClB,cAAI,WAAW;AACb,qBAAS;AAAA;AAET,sBAAU,MAAM;AAAA,QAC1B;AAAA,MACA;AACI,UAAI,WAAW;AACb,eAAO;AACT,aAAO,MAAM,UAAU,MAAM;AAAA,IAC9B;AAAA,IAED,UAAU,SAAS,SAAS,MAAM,IAAI;AACpC,iBAAW,IAAI;AACf,iBAAW,EAAE;AAEb,UAAI,SAAS,GAAI,QAAO;AAExB,aAAO,MAAM,QAAQ,IAAI;AACzB,WAAK,MAAM,QAAQ,EAAE;AAErB,UAAI,SAAS,GAAI,QAAO;AAGxB,UAAI,YAAY;AAChB,aAAO,YAAY,KAAK,QAAQ,EAAE,WAAW;AAC3C,YAAI,KAAK,WAAW,SAAS,MAAM;AACjC;AAAA,MACR;AACI,UAAI,UAAU,KAAK;AACnB,UAAI,UAAU,UAAU;AAGxB,UAAI,UAAU;AACd,aAAO,UAAU,GAAG,QAAQ,EAAE,SAAS;AACrC,YAAI,GAAG,WAAW,OAAO,MAAM;AAC7B;AAAA,MACR;AACI,UAAI,QAAQ,GAAG;AACf,UAAI,QAAQ,QAAQ;AAGpB,UAAI,SAAS,UAAU,QAAQ,UAAU;AACzC,UAAI,gBAAgB;AACpB,UAAI,IAAI;AACR,aAAO,KAAK,QAAQ,EAAE,GAAG;AACvB,YAAI,MAAM,QAAQ;AAChB,cAAI,QAAQ,QAAQ;AAClB,gBAAI,GAAG,WAAW,UAAU,CAAC,MAAM,IAAU;AAG3C,qBAAO,GAAG,MAAM,UAAU,IAAI,CAAC;AAAA,YAC3C,WAAqB,MAAM,GAAG;AAGlB,qBAAO,GAAG,MAAM,UAAU,CAAC;AAAA,YACvC;AAAA,UACA,WAAmB,UAAU,QAAQ;AAC3B,gBAAI,KAAK,WAAW,YAAY,CAAC,MAAM,IAAU;AAG/C,8BAAgB;AAAA,YAC5B,WAAqB,MAAM,GAAG;AAGlB,8BAAgB;AAAA,YAC5B;AAAA,UACA;AACQ;AAAA,QACR;AACM,YAAI,WAAW,KAAK,WAAW,YAAY,CAAC;AAC5C,YAAI,SAAS,GAAG,WAAW,UAAU,CAAC;AACtC,YAAI,aAAa;AACf;AAAA,iBACO,aAAa;AACpB,0BAAgB;AAAA,MACxB;AAEI,UAAI,MAAM;AAGV,WAAK,IAAI,YAAY,gBAAgB,GAAG,KAAK,SAAS,EAAE,GAAG;AACzD,YAAI,MAAM,WAAW,KAAK,WAAW,CAAC,MAAM,IAAU;AACpD,cAAI,IAAI,WAAW;AACjB,mBAAO;AAAA;AAEP,mBAAO;AAAA,QACjB;AAAA,MACA;AAII,UAAI,IAAI,SAAS;AACf,eAAO,MAAM,GAAG,MAAM,UAAU,aAAa;AAAA,WAC1C;AACH,mBAAW;AACX,YAAI,GAAG,WAAW,OAAO,MAAM;AAC7B,YAAE;AACJ,eAAO,GAAG,MAAM,OAAO;AAAA,MAC7B;AAAA,IACG;AAAA,IAED,WAAW,SAAS,UAAU,MAAM;AAClC,aAAO;AAAA,IACR;AAAA,IAED,SAAS,SAAS,QAAQ,MAAM;AAC9B,iBAAW,IAAI;AACf,UAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,UAAI,OAAO,KAAK,WAAW,CAAC;AAC5B,UAAI,UAAU,SAAS;AACvB,UAAI,MAAM;AACV,UAAI,eAAe;AACnB,eAAS,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACzC,eAAO,KAAK,WAAW,CAAC;AACxB,YAAI,SAAS,IAAU;AACnB,cAAI,CAAC,cAAc;AACjB,kBAAM;AACN;AAAA,UACZ;AAAA,QACA,OAAe;AAEP,yBAAe;AAAA,QACvB;AAAA,MACA;AAEI,UAAI,QAAQ,GAAI,QAAO,UAAU,MAAM;AACvC,UAAI,WAAW,QAAQ,EAAG,QAAO;AACjC,aAAO,KAAK,MAAM,GAAG,GAAG;AAAA,IACzB;AAAA,IAED,UAAU,SAAS,SAAS,MAAM,KAAK;AACrC,UAAI,QAAQ,UAAa,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,iCAAiC;AACvG,iBAAW,IAAI;AAEf,UAAI,QAAQ;AACZ,UAAI,MAAM;AACV,UAAI,eAAe;AACnB,UAAI;AAEJ,UAAI,QAAQ,UAAa,IAAI,SAAS,KAAK,IAAI,UAAU,KAAK,QAAQ;AACpE,YAAI,IAAI,WAAW,KAAK,UAAU,QAAQ,KAAM,QAAO;AACvD,YAAI,SAAS,IAAI,SAAS;AAC1B,YAAI,mBAAmB;AACvB,aAAK,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACrC,cAAI,OAAO,KAAK,WAAW,CAAC;AAC5B,cAAI,SAAS,IAAU;AAGnB,gBAAI,CAAC,cAAc;AACjB,sBAAQ,IAAI;AACZ;AAAA,YACd;AAAA,UACA,OAAiB;AACP,gBAAI,qBAAqB,IAAI;AAG3B,6BAAe;AACf,iCAAmB,IAAI;AAAA,YACnC;AACU,gBAAI,UAAU,GAAG;AAEf,kBAAI,SAAS,IAAI,WAAW,MAAM,GAAG;AACnC,oBAAI,EAAE,WAAW,IAAI;AAGnB,wBAAM;AAAA,gBACtB;AAAA,cACA,OAAmB;AAGL,yBAAS;AACT,sBAAM;AAAA,cACpB;AAAA,YACA;AAAA,UACA;AAAA,QACA;AAEM,YAAI,UAAU,IAAK,OAAM;AAAA,iBAA0B,QAAQ,GAAI,OAAM,KAAK;AAC1E,eAAO,KAAK,MAAM,OAAO,GAAG;AAAA,MAClC,OAAW;AACL,aAAK,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACrC,cAAI,KAAK,WAAW,CAAC,MAAM,IAAU;AAGjC,gBAAI,CAAC,cAAc;AACjB,sBAAQ,IAAI;AACZ;AAAA,YACd;AAAA,UACA,WAAqB,QAAQ,IAAI;AAGvB,2BAAe;AACf,kBAAM,IAAI;AAAA,UACpB;AAAA,QACA;AAEM,YAAI,QAAQ,GAAI,QAAO;AACvB,eAAO,KAAK,MAAM,OAAO,GAAG;AAAA,MAClC;AAAA,IACG;AAAA,IAED,SAAS,SAAS,QAAQ,MAAM;AAC9B,iBAAW,IAAI;AACf,UAAI,WAAW;AACf,UAAI,YAAY;AAChB,UAAI,MAAM;AACV,UAAI,eAAe;AAGnB,UAAI,cAAc;AAClB,eAAS,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,EAAE,GAAG;AACzC,YAAI,OAAO,KAAK,WAAW,CAAC;AAC5B,YAAI,SAAS,IAAU;AAGnB,cAAI,CAAC,cAAc;AACjB,wBAAY,IAAI;AAChB;AAAA,UACZ;AACU;AAAA,QACV;AACM,YAAI,QAAQ,IAAI;AAGd,yBAAe;AACf,gBAAM,IAAI;AAAA,QAClB;AACM,YAAI,SAAS,IAAU;AAEnB,cAAI,aAAa;AACf,uBAAW;AAAA,mBACJ,gBAAgB;AACvB,0BAAc;AAAA,QAC1B,WAAiB,aAAa,IAAI;AAG1B,wBAAc;AAAA,QACtB;AAAA,MACA;AAEI,UAAI,aAAa,MAAM,QAAQ;AAAA,MAE3B,gBAAgB;AAAA,MAEhB,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GAAG;AAC3E,eAAO;AAAA,MACb;AACI,aAAO,KAAK,MAAM,UAAU,GAAG;AAAA,IAChC;AAAA,IAED,QAAQ,SAAS,OAAO,YAAY;AAClC,UAAI,eAAe,QAAQ,OAAO,eAAe,UAAU;AACzD,cAAM,IAAI,UAAU,qEAAqE,OAAO,UAAU;AAAA,MAChH;AACI,aAAO,QAAQ,KAAK,UAAU;AAAA,IAC/B;AAAA,IAED,OAAO,SAAS,MAAM,MAAM;AAC1B,iBAAW,IAAI;AAEf,UAAI,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,MAAM,GAAI;AAC5D,UAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,UAAI,OAAO,KAAK,WAAW,CAAC;AAC5B,UAAI,aAAa,SAAS;AAC1B,UAAI;AACJ,UAAI,YAAY;AACd,YAAI,OAAO;AACX,gBAAQ;AAAA,MACd,OAAW;AACL,gBAAQ;AAAA,MACd;AACI,UAAI,WAAW;AACf,UAAI,YAAY;AAChB,UAAI,MAAM;AACV,UAAI,eAAe;AACnB,UAAI,IAAI,KAAK,SAAS;AAItB,UAAI,cAAc;AAGlB,aAAO,KAAK,OAAO,EAAE,GAAG;AACtB,eAAO,KAAK,WAAW,CAAC;AACxB,YAAI,SAAS,IAAU;AAGnB,cAAI,CAAC,cAAc;AACjB,wBAAY,IAAI;AAChB;AAAA,UACZ;AACU;AAAA,QACV;AACM,YAAI,QAAQ,IAAI;AAGd,yBAAe;AACf,gBAAM,IAAI;AAAA,QAClB;AACM,YAAI,SAAS,IAAU;AAEnB,cAAI,aAAa,GAAI,YAAW;AAAA,mBAAW,gBAAgB,EAAG,eAAc;AAAA,QACtF,WAAmB,aAAa,IAAI;AAG5B,wBAAc;AAAA,QACtB;AAAA,MACA;AAEI,UAAI,aAAa,MAAM,QAAQ;AAAA,MAE/B,gBAAgB;AAAA,MAEhB,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GAAG;AACvE,YAAI,QAAQ,IAAI;AACd,cAAI,cAAc,KAAK,WAAY,KAAI,OAAO,IAAI,OAAO,KAAK,MAAM,GAAG,GAAG;AAAA,cAAO,KAAI,OAAO,IAAI,OAAO,KAAK,MAAM,WAAW,GAAG;AAAA,QACxI;AAAA,MACA,OAAW;AACL,YAAI,cAAc,KAAK,YAAY;AACjC,cAAI,OAAO,KAAK,MAAM,GAAG,QAAQ;AACjC,cAAI,OAAO,KAAK,MAAM,GAAG,GAAG;AAAA,QACpC,OAAa;AACL,cAAI,OAAO,KAAK,MAAM,WAAW,QAAQ;AACzC,cAAI,OAAO,KAAK,MAAM,WAAW,GAAG;AAAA,QAC5C;AACM,YAAI,MAAM,KAAK,MAAM,UAAU,GAAG;AAAA,MACxC;AAEI,UAAI,YAAY,EAAG,KAAI,MAAM,KAAK,MAAM,GAAG,YAAY,CAAC;AAAA,eAAW,WAAY,KAAI,MAAM;AAEzF,aAAO;AAAA,IACR;AAAA,IAED,KAAK;AAAA,IACL,WAAW;AAAA,IACX,OAAO;AAAA,IACP,OAAO;AAAA,EACR;AAED,QAAM,QAAQ;AAEd,mBAAiB;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es62.js","sources":["../../node_modules/ethers/lib.esm/abi/typed.js"],"sourcesContent":["/**\n *  A Typed object allows a value to have its type explicitly\n *  specified.\n *\n *  For example, in Solidity, the value ``45`` could represent a\n *  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent\n *  a ``bytes2`` or ``bytes``.\n *\n *  Since JavaScript has no meaningful way to explicitly inform any\n *  APIs which what the type is, this allows transparent interoperation\n *  with Soldity.\n *\n *  @_subsection: api/abi:Typed Values\n */\nimport { assertPrivate, defineProperties } from \"../utils/index.js\";\nconst _gaurd = {};\nfunction n(value, width) {\n    let signed = false;\n    if (width < 0) {\n        signed = true;\n        width *= -1;\n    }\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `${signed ? \"\" : \"u\"}int${width}`, value, { signed, width });\n}\nfunction b(value, size) {\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `bytes${(size) ? size : \"\"}`, value, { size });\n}\nconst _typedSymbol = Symbol.for(\"_ethers_typed\");\n/**\n *  The **Typed** class to wrap values providing explicit type information.\n */\nexport class Typed {\n    /**\n     *  The type, as a Solidity-compatible type.\n     */\n    type;\n    /**\n     *  The actual value.\n     */\n    value;\n    #options;\n    /**\n     *  @_ignore:\n     */\n    _typedSymbol;\n    /**\n     *  @_ignore:\n     */\n    constructor(gaurd, type, value, options) {\n        if (options == null) {\n            options = null;\n        }\n        assertPrivate(_gaurd, gaurd, \"Typed\");\n        defineProperties(this, { _typedSymbol, type, value });\n        this.#options = options;\n        // Check the value is valid\n        this.format();\n    }\n    /**\n     *  Format the type as a Human-Readable type.\n     */\n    format() {\n        if (this.type === \"array\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"dynamicArray\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"tuple\") {\n            return `tuple(${this.value.map((v) => v.format()).join(\",\")})`;\n        }\n        return this.type;\n    }\n    /**\n     *  The default value returned by this type.\n     */\n    defaultValue() {\n        return 0;\n    }\n    /**\n     *  The minimum value for numeric types.\n     */\n    minValue() {\n        return 0;\n    }\n    /**\n     *  The maximum value for numeric types.\n     */\n    maxValue() {\n        return 0;\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].\n     */\n    isBigInt() {\n        return !!(this.type.match(/^u?int[0-9]+$/));\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedData]].\n     */\n    isData() {\n        return this.type.startsWith(\"bytes\");\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedString]].\n     */\n    isString() {\n        return (this.type === \"string\");\n    }\n    /**\n     *  Returns the tuple name, if this is a tuple. Throws otherwise.\n     */\n    get tupleName() {\n        if (this.type !== \"tuple\") {\n            throw TypeError(\"not a tuple\");\n        }\n        return this.#options;\n    }\n    // Returns the length of this type as an array\n    // - `null` indicates the length is unforced, it could be dynamic\n    // - `-1` indicates the length is dynamic\n    // - any other value indicates it is a static array and is its length\n    /**\n     *  Returns the length of the array type or ``-1`` if it is dynamic.\n     *\n     *  Throws if the type is not an array.\n     */\n    get arrayLength() {\n        if (this.type !== \"array\") {\n            throw TypeError(\"not an array\");\n        }\n        if (this.#options === true) {\n            return -1;\n        }\n        if (this.#options === false) {\n            return (this.value).length;\n        }\n        return null;\n    }\n    /**\n     *  Returns a new **Typed** of %%type%% with the %%value%%.\n     */\n    static from(type, value) {\n        return new Typed(_gaurd, type, value);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static uint8(v) { return n(v, 8); }\n    /**\n     *  Return a new ``uint16`` type for %%v%%.\n     */\n    static uint16(v) { return n(v, 16); }\n    /**\n     *  Return a new ``uint24`` type for %%v%%.\n     */\n    static uint24(v) { return n(v, 24); }\n    /**\n     *  Return a new ``uint32`` type for %%v%%.\n     */\n    static uint32(v) { return n(v, 32); }\n    /**\n     *  Return a new ``uint40`` type for %%v%%.\n     */\n    static uint40(v) { return n(v, 40); }\n    /**\n     *  Return a new ``uint48`` type for %%v%%.\n     */\n    static uint48(v) { return n(v, 48); }\n    /**\n     *  Return a new ``uint56`` type for %%v%%.\n     */\n    static uint56(v) { return n(v, 56); }\n    /**\n     *  Return a new ``uint64`` type for %%v%%.\n     */\n    static uint64(v) { return n(v, 64); }\n    /**\n     *  Return a new ``uint72`` type for %%v%%.\n     */\n    static uint72(v) { return n(v, 72); }\n    /**\n     *  Return a new ``uint80`` type for %%v%%.\n     */\n    static uint80(v) { return n(v, 80); }\n    /**\n     *  Return a new ``uint88`` type for %%v%%.\n     */\n    static uint88(v) { return n(v, 88); }\n    /**\n     *  Return a new ``uint96`` type for %%v%%.\n     */\n    static uint96(v) { return n(v, 96); }\n    /**\n     *  Return a new ``uint104`` type for %%v%%.\n     */\n    static uint104(v) { return n(v, 104); }\n    /**\n     *  Return a new ``uint112`` type for %%v%%.\n     */\n    static uint112(v) { return n(v, 112); }\n    /**\n     *  Return a new ``uint120`` type for %%v%%.\n     */\n    static uint120(v) { return n(v, 120); }\n    /**\n     *  Return a new ``uint128`` type for %%v%%.\n     */\n    static uint128(v) { return n(v, 128); }\n    /**\n     *  Return a new ``uint136`` type for %%v%%.\n     */\n    static uint136(v) { return n(v, 136); }\n    /**\n     *  Return a new ``uint144`` type for %%v%%.\n     */\n    static uint144(v) { return n(v, 144); }\n    /**\n     *  Return a new ``uint152`` type for %%v%%.\n     */\n    static uint152(v) { return n(v, 152); }\n    /**\n     *  Return a new ``uint160`` type for %%v%%.\n     */\n    static uint160(v) { return n(v, 160); }\n    /**\n     *  Return a new ``uint168`` type for %%v%%.\n     */\n    static uint168(v) { return n(v, 168); }\n    /**\n     *  Return a new ``uint176`` type for %%v%%.\n     */\n    static uint176(v) { return n(v, 176); }\n    /**\n     *  Return a new ``uint184`` type for %%v%%.\n     */\n    static uint184(v) { return n(v, 184); }\n    /**\n     *  Return a new ``uint192`` type for %%v%%.\n     */\n    static uint192(v) { return n(v, 192); }\n    /**\n     *  Return a new ``uint200`` type for %%v%%.\n     */\n    static uint200(v) { return n(v, 200); }\n    /**\n     *  Return a new ``uint208`` type for %%v%%.\n     */\n    static uint208(v) { return n(v, 208); }\n    /**\n     *  Return a new ``uint216`` type for %%v%%.\n     */\n    static uint216(v) { return n(v, 216); }\n    /**\n     *  Return a new ``uint224`` type for %%v%%.\n     */\n    static uint224(v) { return n(v, 224); }\n    /**\n     *  Return a new ``uint232`` type for %%v%%.\n     */\n    static uint232(v) { return n(v, 232); }\n    /**\n     *  Return a new ``uint240`` type for %%v%%.\n     */\n    static uint240(v) { return n(v, 240); }\n    /**\n     *  Return a new ``uint248`` type for %%v%%.\n     */\n    static uint248(v) { return n(v, 248); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint256(v) { return n(v, 256); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint(v) { return n(v, 256); }\n    /**\n     *  Return a new ``int8`` type for %%v%%.\n     */\n    static int8(v) { return n(v, -8); }\n    /**\n     *  Return a new ``int16`` type for %%v%%.\n     */\n    static int16(v) { return n(v, -16); }\n    /**\n     *  Return a new ``int24`` type for %%v%%.\n     */\n    static int24(v) { return n(v, -24); }\n    /**\n     *  Return a new ``int32`` type for %%v%%.\n     */\n    static int32(v) { return n(v, -32); }\n    /**\n     *  Return a new ``int40`` type for %%v%%.\n     */\n    static int40(v) { return n(v, -40); }\n    /**\n     *  Return a new ``int48`` type for %%v%%.\n     */\n    static int48(v) { return n(v, -48); }\n    /**\n     *  Return a new ``int56`` type for %%v%%.\n     */\n    static int56(v) { return n(v, -56); }\n    /**\n     *  Return a new ``int64`` type for %%v%%.\n     */\n    static int64(v) { return n(v, -64); }\n    /**\n     *  Return a new ``int72`` type for %%v%%.\n     */\n    static int72(v) { return n(v, -72); }\n    /**\n     *  Return a new ``int80`` type for %%v%%.\n     */\n    static int80(v) { return n(v, -80); }\n    /**\n     *  Return a new ``int88`` type for %%v%%.\n     */\n    static int88(v) { return n(v, -88); }\n    /**\n     *  Return a new ``int96`` type for %%v%%.\n     */\n    static int96(v) { return n(v, -96); }\n    /**\n     *  Return a new ``int104`` type for %%v%%.\n     */\n    static int104(v) { return n(v, -104); }\n    /**\n     *  Return a new ``int112`` type for %%v%%.\n     */\n    static int112(v) { return n(v, -112); }\n    /**\n     *  Return a new ``int120`` type for %%v%%.\n     */\n    static int120(v) { return n(v, -120); }\n    /**\n     *  Return a new ``int128`` type for %%v%%.\n     */\n    static int128(v) { return n(v, -128); }\n    /**\n     *  Return a new ``int136`` type for %%v%%.\n     */\n    static int136(v) { return n(v, -136); }\n    /**\n     *  Return a new ``int144`` type for %%v%%.\n     */\n    static int144(v) { return n(v, -144); }\n    /**\n     *  Return a new ``int52`` type for %%v%%.\n     */\n    static int152(v) { return n(v, -152); }\n    /**\n     *  Return a new ``int160`` type for %%v%%.\n     */\n    static int160(v) { return n(v, -160); }\n    /**\n     *  Return a new ``int168`` type for %%v%%.\n     */\n    static int168(v) { return n(v, -168); }\n    /**\n     *  Return a new ``int176`` type for %%v%%.\n     */\n    static int176(v) { return n(v, -176); }\n    /**\n     *  Return a new ``int184`` type for %%v%%.\n     */\n    static int184(v) { return n(v, -184); }\n    /**\n     *  Return a new ``int92`` type for %%v%%.\n     */\n    static int192(v) { return n(v, -192); }\n    /**\n     *  Return a new ``int200`` type for %%v%%.\n     */\n    static int200(v) { return n(v, -200); }\n    /**\n     *  Return a new ``int208`` type for %%v%%.\n     */\n    static int208(v) { return n(v, -208); }\n    /**\n     *  Return a new ``int216`` type for %%v%%.\n     */\n    static int216(v) { return n(v, -216); }\n    /**\n     *  Return a new ``int224`` type for %%v%%.\n     */\n    static int224(v) { return n(v, -224); }\n    /**\n     *  Return a new ``int232`` type for %%v%%.\n     */\n    static int232(v) { return n(v, -232); }\n    /**\n     *  Return a new ``int240`` type for %%v%%.\n     */\n    static int240(v) { return n(v, -240); }\n    /**\n     *  Return a new ``int248`` type for %%v%%.\n     */\n    static int248(v) { return n(v, -248); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int256(v) { return n(v, -256); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int(v) { return n(v, -256); }\n    /**\n     *  Return a new ``bytes1`` type for %%v%%.\n     */\n    static bytes1(v) { return b(v, 1); }\n    /**\n     *  Return a new ``bytes2`` type for %%v%%.\n     */\n    static bytes2(v) { return b(v, 2); }\n    /**\n     *  Return a new ``bytes3`` type for %%v%%.\n     */\n    static bytes3(v) { return b(v, 3); }\n    /**\n     *  Return a new ``bytes4`` type for %%v%%.\n     */\n    static bytes4(v) { return b(v, 4); }\n    /**\n     *  Return a new ``bytes5`` type for %%v%%.\n     */\n    static bytes5(v) { return b(v, 5); }\n    /**\n     *  Return a new ``bytes6`` type for %%v%%.\n     */\n    static bytes6(v) { return b(v, 6); }\n    /**\n     *  Return a new ``bytes7`` type for %%v%%.\n     */\n    static bytes7(v) { return b(v, 7); }\n    /**\n     *  Return a new ``bytes8`` type for %%v%%.\n     */\n    static bytes8(v) { return b(v, 8); }\n    /**\n     *  Return a new ``bytes9`` type for %%v%%.\n     */\n    static bytes9(v) { return b(v, 9); }\n    /**\n     *  Return a new ``bytes10`` type for %%v%%.\n     */\n    static bytes10(v) { return b(v, 10); }\n    /**\n     *  Return a new ``bytes11`` type for %%v%%.\n     */\n    static bytes11(v) { return b(v, 11); }\n    /**\n     *  Return a new ``bytes12`` type for %%v%%.\n     */\n    static bytes12(v) { return b(v, 12); }\n    /**\n     *  Return a new ``bytes13`` type for %%v%%.\n     */\n    static bytes13(v) { return b(v, 13); }\n    /**\n     *  Return a new ``bytes14`` type for %%v%%.\n     */\n    static bytes14(v) { return b(v, 14); }\n    /**\n     *  Return a new ``bytes15`` type for %%v%%.\n     */\n    static bytes15(v) { return b(v, 15); }\n    /**\n     *  Return a new ``bytes16`` type for %%v%%.\n     */\n    static bytes16(v) { return b(v, 16); }\n    /**\n     *  Return a new ``bytes17`` type for %%v%%.\n     */\n    static bytes17(v) { return b(v, 17); }\n    /**\n     *  Return a new ``bytes18`` type for %%v%%.\n     */\n    static bytes18(v) { return b(v, 18); }\n    /**\n     *  Return a new ``bytes19`` type for %%v%%.\n     */\n    static bytes19(v) { return b(v, 19); }\n    /**\n     *  Return a new ``bytes20`` type for %%v%%.\n     */\n    static bytes20(v) { return b(v, 20); }\n    /**\n     *  Return a new ``bytes21`` type for %%v%%.\n     */\n    static bytes21(v) { return b(v, 21); }\n    /**\n     *  Return a new ``bytes22`` type for %%v%%.\n     */\n    static bytes22(v) { return b(v, 22); }\n    /**\n     *  Return a new ``bytes23`` type for %%v%%.\n     */\n    static bytes23(v) { return b(v, 23); }\n    /**\n     *  Return a new ``bytes24`` type for %%v%%.\n     */\n    static bytes24(v) { return b(v, 24); }\n    /**\n     *  Return a new ``bytes25`` type for %%v%%.\n     */\n    static bytes25(v) { return b(v, 25); }\n    /**\n     *  Return a new ``bytes26`` type for %%v%%.\n     */\n    static bytes26(v) { return b(v, 26); }\n    /**\n     *  Return a new ``bytes27`` type for %%v%%.\n     */\n    static bytes27(v) { return b(v, 27); }\n    /**\n     *  Return a new ``bytes28`` type for %%v%%.\n     */\n    static bytes28(v) { return b(v, 28); }\n    /**\n     *  Return a new ``bytes29`` type for %%v%%.\n     */\n    static bytes29(v) { return b(v, 29); }\n    /**\n     *  Return a new ``bytes30`` type for %%v%%.\n     */\n    static bytes30(v) { return b(v, 30); }\n    /**\n     *  Return a new ``bytes31`` type for %%v%%.\n     */\n    static bytes31(v) { return b(v, 31); }\n    /**\n     *  Return a new ``bytes32`` type for %%v%%.\n     */\n    static bytes32(v) { return b(v, 32); }\n    /**\n     *  Return a new ``address`` type for %%v%%.\n     */\n    static address(v) { return new Typed(_gaurd, \"address\", v); }\n    /**\n     *  Return a new ``bool`` type for %%v%%.\n     */\n    static bool(v) { return new Typed(_gaurd, \"bool\", !!v); }\n    /**\n     *  Return a new ``bytes`` type for %%v%%.\n     */\n    static bytes(v) { return new Typed(_gaurd, \"bytes\", v); }\n    /**\n     *  Return a new ``string`` type for %%v%%.\n     */\n    static string(v) { return new Typed(_gaurd, \"string\", v); }\n    /**\n     *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.\n     */\n    static array(v, dynamic) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"array\", v, dynamic);\n    }\n    /**\n     *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.\n     */\n    static tuple(v, name) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"tuple\", v, name);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static overrides(v) {\n        return new Typed(_gaurd, \"overrides\", Object.assign({}, v));\n    }\n    /**\n     *  Returns true only if %%value%% is a [[Typed]] instance.\n     */\n    static isTyped(value) {\n        return (value\n            && typeof (value) === \"object\"\n            && \"_typedSymbol\" in value\n            && value._typedSymbol === _typedSymbol);\n    }\n    /**\n     *  If the value is a [[Typed]] instance, validates the underlying value\n     *  and returns it, otherwise returns value directly.\n     *\n     *  This is useful for functions that with to accept either a [[Typed]]\n     *  object or values.\n     */\n    static dereference(value, type) {\n        if (Typed.isTyped(value)) {\n            if (value.type !== type) {\n                throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);\n            }\n            return value.value;\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=typed.js.map"],"names":[],"mappings":"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AAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,E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","x_google_ignoreList":[0]}

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

@@ -1,24 +1,146 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Coder } from "./standards-sdk.es41.js";
-class AnonymousCoder extends Coder {
-  constructor(coder) {
-    super(coder.name, coder.type, "_", coder.dynamic);
-    __publicField(this, "coder");
-    this.coder = coder;
+import { getBytes } from "./standards-sdk.es45.js";
+import { assertArgument } from "./standards-sdk.es44.js";
+function errorFunc(reason, offset, bytes, output, badCodepoint) {
+  assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+}
+function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+    let i = 0;
+    for (let o = offset + 1; o < bytes.length; o++) {
+      if (bytes[o] >> 6 !== 2) {
+        break;
+      }
+      i++;
+    }
+    return i;
+  }
+  if (reason === "OVERRUN") {
+    return bytes.length - offset - 1;
+  }
+  return 0;
+}
+function replaceFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "OVERLONG") {
+    assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+    output.push(badCodepoint);
+    return 0;
   }
-  defaultValue() {
-    return this.coder.defaultValue();
+  output.push(65533);
+  return ignoreFunc(reason, offset, bytes);
+}
+const Utf8ErrorFuncs = Object.freeze({
+  error: errorFunc,
+  ignore: ignoreFunc,
+  replace: replaceFunc
+});
+function getUtf8CodePoints(_bytes, onError) {
+  if (onError == null) {
+    onError = Utf8ErrorFuncs.error;
   }
-  encode(writer, value) {
-    return this.coder.encode(writer, value);
+  const bytes = getBytes(_bytes, "bytes");
+  const result = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const c = bytes[i++];
+    if (c >> 7 === 0) {
+      result.push(c);
+      continue;
+    }
+    let extraLength = null;
+    let overlongMask = null;
+    if ((c & 224) === 192) {
+      extraLength = 1;
+      overlongMask = 127;
+    } else if ((c & 240) === 224) {
+      extraLength = 2;
+      overlongMask = 2047;
+    } else if ((c & 248) === 240) {
+      extraLength = 3;
+      overlongMask = 65535;
+    } else {
+      if ((c & 192) === 128) {
+        i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
+      } else {
+        i += onError("BAD_PREFIX", i - 1, bytes, result);
+      }
+      continue;
+    }
+    if (i - 1 + extraLength >= bytes.length) {
+      i += onError("OVERRUN", i - 1, bytes, result);
+      continue;
+    }
+    let res = c & (1 << 8 - extraLength - 1) - 1;
+    for (let j = 0; j < extraLength; j++) {
+      let nextChar = bytes[i];
+      if ((nextChar & 192) != 128) {
+        i += onError("MISSING_CONTINUE", i, bytes, result);
+        res = null;
+        break;
+      }
+      res = res << 6 | nextChar & 63;
+      i++;
+    }
+    if (res === null) {
+      continue;
+    }
+    if (res > 1114111) {
+      i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res >= 55296 && res <= 57343) {
+      i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res <= overlongMask) {
+      i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    result.push(res);
   }
-  decode(reader) {
-    return this.coder.decode(reader);
+  return result;
+}
+function toUtf8Bytes(str, form) {
+  assertArgument(typeof str === "string", "invalid string value", "str", str);
+  let result = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      result.push(c);
+    } else if (c < 2048) {
+      result.push(c >> 6 | 192);
+      result.push(c & 63 | 128);
+    } else if ((c & 64512) == 55296) {
+      i++;
+      const c2 = str.charCodeAt(i);
+      assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
+      const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+      result.push(pair >> 18 | 240);
+      result.push(pair >> 12 & 63 | 128);
+      result.push(pair >> 6 & 63 | 128);
+      result.push(pair & 63 | 128);
+    } else {
+      result.push(c >> 12 | 224);
+      result.push(c >> 6 & 63 | 128);
+      result.push(c & 63 | 128);
+    }
   }
+  return new Uint8Array(result);
+}
+function _toUtf8String(codePoints) {
+  return codePoints.map((codePoint) => {
+    if (codePoint <= 65535) {
+      return String.fromCharCode(codePoint);
+    }
+    codePoint -= 65536;
+    return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
+  }).join("");
+}
+function toUtf8String(bytes, onError) {
+  return _toUtf8String(getUtf8CodePoints(bytes, onError));
 }
 export {
-  AnonymousCoder
+  Utf8ErrorFuncs,
+  toUtf8Bytes,
+  toUtf8String
 };
 //# sourceMappingURL=standards-sdk.es63.js.map

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

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