@hashgraphonline/standards-sdk 0.0.86 → 0.0.87

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es56.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"standards-sdk.es56.js","sources":["../../node_modules/axios/lib/defaults/index.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\n */\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nconst defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: ['xhr', 'http', 'fetch'],\n\n  transformRequest: [function transformRequest(data, headers) {\n    const contentType = headers.getContentType() || '';\n    const hasJSONContentType = contentType.indexOf('application/json') > -1;\n    const isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    const isFormData = utils.isFormData(data);\n\n    if (isFormData) {\n      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n    }\n\n    if (utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data) ||\n      utils.isReadableStream(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n      return data.toString();\n    }\n\n    let isFileList;\n\n    if (isObjectPayload) {\n      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {\n        return toURLEncodedForm(data, this.formSerializer).toString();\n      }\n\n      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n        const _FormData = this.env && this.env.FormData;\n\n        return toFormData(\n          isFileList ? {'files[]': data} : data,\n          _FormData && new _FormData(),\n          this.formSerializer\n        );\n      }\n    }\n\n    if (isObjectPayload || hasJSONContentType ) {\n      headers.setContentType('application/json', false);\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    const transitional = this.transitional || defaults.transitional;\n    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    const JSONRequested = this.responseType === 'json';\n\n    if (utils.isResponse(data) || utils.isReadableStream(data)) {\n      return data;\n    }\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      const silentJSONParsing = transitional && transitional.silentJSONParsing;\n      const strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: platform.classes.FormData,\n    Blob: platform.classes.Blob\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*',\n      'Content-Type': undefined\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {\n  defaults.headers[method] = {};\n});\n\nexport default defaults;\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,167 +1,55 @@
-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();
+import utils from "./standards-sdk.es52.js";
+function parsePropPath(name) {
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
+    return match[0] === "[]" ? "" : match[1] || match[0];
+  });
+}
+function arrayToObject(arr) {
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
+  for (i = 0; i < len; i++) {
+    key = keys[i];
+    obj[key] = arr[key];
+  }
+  return obj;
+}
+function formDataToJSON(formData) {
+  function buildPath(path, value, target, index) {
+    let name = path[index++];
+    if (name === "__proto__") return true;
+    const isNumericKey = Number.isFinite(+name);
+    const isLast = index >= path.length;
+    name = !name && utils.isArray(target) ? target.length : name;
+    if (isLast) {
+      if (utils.hasOwnProp(target, name)) {
+        target[name] = [target[name], value];
+      } else {
+        target[name] = value;
       }
+      return !isNumericKey;
     }
-    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];
+    if (!target[name] || !utils.isObject(target[name])) {
+      target[name] = [];
+    }
+    const result = buildPath(path, value, target[name], index);
+    if (result && utils.isArray(target[name])) {
+      target[name] = arrayToObject(target[name]);
     }
+    return !isNumericKey;
   }
-  queue.push(new Item(fun, args));
-  if (queue.length === 1 && !draining) {
-    runTimeout(drainQueue);
+  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+    const obj = {};
+    utils.forEachEntry(formData, (name, value) => {
+      buildPath(parsePropPath(name), value, obj, 0);
+    });
+    return obj;
   }
-};
-function Item(fun, array) {
-  this.fun = fun;
-  this.array = array;
-}
-Item.prototype.run = function() {
-  this.fun.apply(null, this.array);
-};
-process.title = "browser";
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = "";
-process.versions = {};
-function noop() {
+  return null;
 }
-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");
-};
-process.cwd = function() {
-  return "/";
-};
-process.chdir = function(dir) {
-  throw new Error("process.chdir is not supported");
-};
-process.umask = function() {
-  return 0;
-};
-var browserExports = browser.exports;
-const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
 export {
-  process$1 as default,
-  process$1 as process
+  formDataToJSON as default
 };
 //# sourceMappingURL=standards-sdk.es57.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es57.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.es57.js","sources":["../../node_modules/axios/lib/helpers/formDataToJSON.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\n */\nfunction parsePropPath(name) {\n  // foo[x][y][z]\n  // foo.x.y.z\n  // foo-x-y-z\n  // foo x y z\n  return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(match => {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array<any>} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n  const obj = {};\n  const keys = Object.keys(arr);\n  let i;\n  const len = keys.length;\n  let key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object<string, any> | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    let name = path[index++];\n\n    if (name === '__proto__') return true;\n\n    const isNumericKey = Number.isFinite(+name);\n    const isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProp(target, name)) {\n        target[name] = [target[name], value];\n      } else {\n        target[name] = value;\n      }\n\n      return !isNumericKey;\n    }\n\n    if (!target[name] || !utils.isObject(target[name])) {\n      target[name] = [];\n    }\n\n    const result = buildPath(path, value, target[name], index);\n\n    if (result && utils.isArray(target[name])) {\n      target[name] = arrayToObject(target[name]);\n    }\n\n    return !isNumericKey;\n  }\n\n  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n    const obj = {};\n\n    utils.forEachEntry(formData, (name, value) => {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nexport default formDataToJSON;\n"],"names":[],"mappings":";AAWA,SAAS,cAAc,MAAM;AAK3B,SAAO,MAAM,SAAS,iBAAiB,IAAI,EAAE,IAAI,WAAS;AACxD,WAAO,MAAM,CAAC,MAAM,OAAO,KAAK,MAAM,CAAC,KAAK,MAAM,CAAC;AAAA,EACvD,CAAG;AACH;AASA,SAAS,cAAc,KAAK;AAC1B,QAAM,MAAM,CAAE;AACd,QAAM,OAAO,OAAO,KAAK,GAAG;AAC5B,MAAI;AACJ,QAAM,MAAM,KAAK;AACjB,MAAI;AACJ,OAAK,IAAI,GAAG,IAAI,KAAK,KAAK;AACxB,UAAM,KAAK,CAAC;AACZ,QAAI,GAAG,IAAI,IAAI,GAAG;AAAA,EACtB;AACE,SAAO;AACT;AASA,SAAS,eAAe,UAAU;AAChC,WAAS,UAAU,MAAM,OAAO,QAAQ,OAAO;AAC7C,QAAI,OAAO,KAAK,OAAO;AAEvB,QAAI,SAAS,YAAa,QAAO;AAEjC,UAAM,eAAe,OAAO,SAAS,CAAC,IAAI;AAC1C,UAAM,SAAS,SAAS,KAAK;AAC7B,WAAO,CAAC,QAAQ,MAAM,QAAQ,MAAM,IAAI,OAAO,SAAS;AAExD,QAAI,QAAQ;AACV,UAAI,MAAM,WAAW,QAAQ,IAAI,GAAG;AAClC,eAAO,IAAI,IAAI,CAAC,OAAO,IAAI,GAAG,KAAK;AAAA,MAC3C,OAAa;AACL,eAAO,IAAI,IAAI;AAAA,MACvB;AAEM,aAAO,CAAC;AAAA,IACd;AAEI,QAAI,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,SAAS,OAAO,IAAI,CAAC,GAAG;AAClD,aAAO,IAAI,IAAI,CAAE;AAAA,IACvB;AAEI,UAAM,SAAS,UAAU,MAAM,OAAO,OAAO,IAAI,GAAG,KAAK;AAEzD,QAAI,UAAU,MAAM,QAAQ,OAAO,IAAI,CAAC,GAAG;AACzC,aAAO,IAAI,IAAI,cAAc,OAAO,IAAI,CAAC;AAAA,IAC/C;AAEI,WAAO,CAAC;AAAA,EACZ;AAEE,MAAI,MAAM,WAAW,QAAQ,KAAK,MAAM,WAAW,SAAS,OAAO,GAAG;AACpE,UAAM,MAAM,CAAE;AAEd,UAAM,aAAa,UAAU,CAAC,MAAM,UAAU;AAC5C,gBAAU,cAAc,IAAI,GAAG,OAAO,KAAK,CAAC;AAAA,IAClD,CAAK;AAED,WAAO;AAAA,EACX;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

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

@@ -1,6 +1,13 @@
-const global = globalThis || void 0 || self;
+import AxiosError from "./standards-sdk.es63.js";
+import utils from "./standards-sdk.es52.js";
+function CanceledError(message, config, request) {
+  AxiosError.call(this, message == null ? "canceled" : message, AxiosError.ERR_CANCELED, config, request);
+  this.name = "CanceledError";
+}
+utils.inherits(CanceledError, AxiosError, {
+  __CANCEL__: true
+});
 export {
-  global as default,
-  global
+  CanceledError as default
 };
 //# sourceMappingURL=standards-sdk.es58.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es58.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.es58.js","sources":["../../node_modules/axios/lib/cancel/CanceledError.js"],"sourcesContent":["'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\n */\nfunction CanceledError(message, config, request) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nexport default CanceledError;\n"],"names":[],"mappings":";;AAcA,SAAS,cAAc,SAAS,QAAQ,SAAS;AAE/C,aAAW,KAAK,MAAM,WAAW,OAAO,aAAa,SAAS,WAAW,cAAc,QAAQ,OAAO;AACtG,OAAK,OAAO;AACd;AAEA,MAAM,SAAS,eAAe,YAAY;AAAA,EACxC,YAAY;AACd,CAAC;","x_google_ignoreList":[0]}

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

@@ -1,35 +1,100 @@
-import utils from "./standards-sdk.es35.js";
-import AxiosURLSearchParams from "./standards-sdk.es75.js";
-function encode(val) {
-  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
-}
-function buildURL(url, params, options) {
-  if (!params) {
-    return url;
-  }
-  const _encode = options && options.encode || encode;
-  if (utils.isFunction(options)) {
-    options = {
-      serialize: options
+import CanceledError from "./standards-sdk.es58.js";
+class CancelToken {
+  constructor(executor) {
+    if (typeof executor !== "function") {
+      throw new TypeError("executor must be a function.");
+    }
+    let resolvePromise;
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+    const token = this;
+    this.promise.then((cancel) => {
+      if (!token._listeners) return;
+      let i = token._listeners.length;
+      while (i-- > 0) {
+        token._listeners[i](cancel);
+      }
+      token._listeners = null;
+    });
+    this.promise.then = (onfulfilled) => {
+      let _resolve;
+      const promise = new Promise((resolve) => {
+        token.subscribe(resolve);
+        _resolve = resolve;
+      }).then(onfulfilled);
+      promise.cancel = function reject() {
+        token.unsubscribe(_resolve);
+      };
+      return promise;
     };
+    executor(function cancel(message, config, request) {
+      if (token.reason) {
+        return;
+      }
+      token.reason = new CanceledError(message, config, request);
+      resolvePromise(token.reason);
+    });
   }
-  const serializeFn = options && options.serialize;
-  let serializedParams;
-  if (serializeFn) {
-    serializedParams = serializeFn(params, options);
-  } else {
-    serializedParams = utils.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  }
+  /**
+   * Subscribe to the cancel signal
+   */
+  subscribe(listener) {
+    if (this.reason) {
+      listener(this.reason);
+      return;
+    }
+    if (this._listeners) {
+      this._listeners.push(listener);
+    } else {
+      this._listeners = [listener];
+    }
   }
-  if (serializedParams) {
-    const hashmarkIndex = url.indexOf("#");
-    if (hashmarkIndex !== -1) {
-      url = url.slice(0, hashmarkIndex);
+  /**
+   * Unsubscribe from the cancel signal
+   */
+  unsubscribe(listener) {
+    if (!this._listeners) {
+      return;
+    }
+    const index = this._listeners.indexOf(listener);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
     }
-    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
   }
-  return url;
+  toAbortSignal() {
+    const controller = new AbortController();
+    const abort = (err) => {
+      controller.abort(err);
+    };
+    this.subscribe(abort);
+    controller.signal.unsubscribe = () => this.unsubscribe(abort);
+    return controller.signal;
+  }
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let cancel;
+    const token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token,
+      cancel
+    };
+  }
 }
 export {
-  buildURL as default
+  CancelToken as default
 };
 //# sourceMappingURL=standards-sdk.es59.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es59.js","sources":["../../node_modules/axios/lib/helpers/buildURL.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\n */\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?(object|Function)} options\n *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n  \n  const _encode = options && options.encode || encode;\n\n  if (utils.isFunction(options)) {\n    options = {\n      serialize: options\n    };\n  } \n\n  const serializeFn = options && options.serialize;\n\n  let serializedParams;\n\n  if (serializeFn) {\n    serializedParams = serializeFn(params, options);\n  } else {\n    serializedParams = utils.isURLSearchParams(params) ?\n      params.toString() :\n      new AxiosURLSearchParams(params, options).toString(_encode);\n  }\n\n  if (serializedParams) {\n    const hashmarkIndex = url.indexOf(\"#\");\n\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n}\n"],"names":[],"mappings":";;AAaA,SAAS,OAAO,KAAK;AACnB,SAAO,mBAAmB,GAAG,EAC3B,QAAQ,SAAS,GAAG,EACpB,QAAQ,QAAQ,GAAG,EACnB,QAAQ,SAAS,GAAG,EACpB,QAAQ,QAAQ,GAAG,EACnB,QAAQ,SAAS,GAAG,EACpB,QAAQ,SAAS,GAAG;AACxB;AAWe,SAAS,SAAS,KAAK,QAAQ,SAAS;AAErD,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACX;AAEE,QAAM,UAAU,WAAW,QAAQ,UAAU;AAE7C,MAAI,MAAM,WAAW,OAAO,GAAG;AAC7B,cAAU;AAAA,MACR,WAAW;AAAA,IACZ;AAAA,EACF;AAED,QAAM,cAAc,WAAW,QAAQ;AAEvC,MAAI;AAEJ,MAAI,aAAa;AACf,uBAAmB,YAAY,QAAQ,OAAO;AAAA,EAClD,OAAS;AACL,uBAAmB,MAAM,kBAAkB,MAAM,IAC/C,OAAO,SAAU,IACjB,IAAI,qBAAqB,QAAQ,OAAO,EAAE,SAAS,OAAO;AAAA,EAChE;AAEE,MAAI,kBAAkB;AACpB,UAAM,gBAAgB,IAAI,QAAQ,GAAG;AAErC,QAAI,kBAAkB,IAAI;AACxB,YAAM,IAAI,MAAM,GAAG,aAAa;AAAA,IACtC;AACI,YAAQ,IAAI,QAAQ,GAAG,MAAM,KAAK,MAAM,OAAO;AAAA,EACnD;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es59.js","sources":["../../node_modules/axios/lib/cancel/CancelToken.js"],"sourcesContent":["'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n  constructor(executor) {\n    if (typeof executor !== 'function') {\n      throw new TypeError('executor must be a function.');\n    }\n\n    let resolvePromise;\n\n    this.promise = new Promise(function promiseExecutor(resolve) {\n      resolvePromise = resolve;\n    });\n\n    const token = this;\n\n    // eslint-disable-next-line func-names\n    this.promise.then(cancel => {\n      if (!token._listeners) return;\n\n      let i = token._listeners.length;\n\n      while (i-- > 0) {\n        token._listeners[i](cancel);\n      }\n      token._listeners = null;\n    });\n\n    // eslint-disable-next-line func-names\n    this.promise.then = onfulfilled => {\n      let _resolve;\n      // eslint-disable-next-line func-names\n      const promise = new Promise(resolve => {\n        token.subscribe(resolve);\n        _resolve = resolve;\n      }).then(onfulfilled);\n\n      promise.cancel = function reject() {\n        token.unsubscribe(_resolve);\n      };\n\n      return promise;\n    };\n\n    executor(function cancel(message, config, request) {\n      if (token.reason) {\n        // Cancellation has already been requested\n        return;\n      }\n\n      token.reason = new CanceledError(message, config, request);\n      resolvePromise(token.reason);\n    });\n  }\n\n  /**\n   * Throws a `CanceledError` if cancellation has been requested.\n   */\n  throwIfRequested() {\n    if (this.reason) {\n      throw this.reason;\n    }\n  }\n\n  /**\n   * Subscribe to the cancel signal\n   */\n\n  subscribe(listener) {\n    if (this.reason) {\n      listener(this.reason);\n      return;\n    }\n\n    if (this._listeners) {\n      this._listeners.push(listener);\n    } else {\n      this._listeners = [listener];\n    }\n  }\n\n  /**\n   * Unsubscribe from the cancel signal\n   */\n\n  unsubscribe(listener) {\n    if (!this._listeners) {\n      return;\n    }\n    const index = this._listeners.indexOf(listener);\n    if (index !== -1) {\n      this._listeners.splice(index, 1);\n    }\n  }\n\n  toAbortSignal() {\n    const controller = new AbortController();\n\n    const abort = (err) => {\n      controller.abort(err);\n    };\n\n    this.subscribe(abort);\n\n    controller.signal.unsubscribe = () => this.unsubscribe(abort);\n\n    return controller.signal;\n  }\n\n  /**\n   * Returns an object that contains a new `CancelToken` and a function that, when called,\n   * cancels the `CancelToken`.\n   */\n  static source() {\n    let cancel;\n    const token = new CancelToken(function executor(c) {\n      cancel = c;\n    });\n    return {\n      token,\n      cancel\n    };\n  }\n}\n\nexport default CancelToken;\n"],"names":[],"mappings":";AAWA,MAAM,YAAY;AAAA,EAChB,YAAY,UAAU;AACpB,QAAI,OAAO,aAAa,YAAY;AAClC,YAAM,IAAI,UAAU,8BAA8B;AAAA,IACxD;AAEI,QAAI;AAEJ,SAAK,UAAU,IAAI,QAAQ,SAAS,gBAAgB,SAAS;AAC3D,uBAAiB;AAAA,IACvB,CAAK;AAED,UAAM,QAAQ;AAGd,SAAK,QAAQ,KAAK,YAAU;AAC1B,UAAI,CAAC,MAAM,WAAY;AAEvB,UAAI,IAAI,MAAM,WAAW;AAEzB,aAAO,MAAM,GAAG;AACd,cAAM,WAAW,CAAC,EAAE,MAAM;AAAA,MAClC;AACM,YAAM,aAAa;AAAA,IACzB,CAAK;AAGD,SAAK,QAAQ,OAAO,iBAAe;AACjC,UAAI;AAEJ,YAAM,UAAU,IAAI,QAAQ,aAAW;AACrC,cAAM,UAAU,OAAO;AACvB,mBAAW;AAAA,MACnB,CAAO,EAAE,KAAK,WAAW;AAEnB,cAAQ,SAAS,SAAS,SAAS;AACjC,cAAM,YAAY,QAAQ;AAAA,MAC3B;AAED,aAAO;AAAA,IACR;AAED,aAAS,SAAS,OAAO,SAAS,QAAQ,SAAS;AACjD,UAAI,MAAM,QAAQ;AAEhB;AAAA,MACR;AAEM,YAAM,SAAS,IAAI,cAAc,SAAS,QAAQ,OAAO;AACzD,qBAAe,MAAM,MAAM;AAAA,IACjC,CAAK;AAAA,EACL;AAAA;AAAA;AAAA;AAAA,EAKE,mBAAmB;AACjB,QAAI,KAAK,QAAQ;AACf,YAAM,KAAK;AAAA,IACjB;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAME,UAAU,UAAU;AAClB,QAAI,KAAK,QAAQ;AACf,eAAS,KAAK,MAAM;AACpB;AAAA,IACN;AAEI,QAAI,KAAK,YAAY;AACnB,WAAK,WAAW,KAAK,QAAQ;AAAA,IACnC,OAAW;AACL,WAAK,aAAa,CAAC,QAAQ;AAAA,IACjC;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAME,YAAY,UAAU;AACpB,QAAI,CAAC,KAAK,YAAY;AACpB;AAAA,IACN;AACI,UAAM,QAAQ,KAAK,WAAW,QAAQ,QAAQ;AAC9C,QAAI,UAAU,IAAI;AAChB,WAAK,WAAW,OAAO,OAAO,CAAC;AAAA,IACrC;AAAA,EACA;AAAA,EAEE,gBAAgB;AACd,UAAM,aAAa,IAAI,gBAAiB;AAExC,UAAM,QAAQ,CAAC,QAAQ;AACrB,iBAAW,MAAM,GAAG;AAAA,IACrB;AAED,SAAK,UAAU,KAAK;AAEpB,eAAW,OAAO,cAAc,MAAM,KAAK,YAAY,KAAK;AAE5D,WAAO,WAAW;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA,EAME,OAAO,SAAS;AACd,QAAI;AACJ,UAAM,QAAQ,IAAI,YAAY,SAAS,SAAS,GAAG;AACjD,eAAS;AAAA,IACf,CAAK;AACD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IACD;AAAA,EACL;AACA;","x_google_ignoreList":[0]}

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

@@ -1,66 +1,7 @@
-import utils from "./standards-sdk.es35.js";
-class InterceptorManager {
-  constructor() {
-    this.handlers = [];
-  }
-  /**
-   * Add a new interceptor to the stack
-   *
-   * @param {Function} fulfilled The function to handle `then` for a `Promise`
-   * @param {Function} rejected The function to handle `reject` for a `Promise`
-   *
-   * @return {Number} An ID used to remove interceptor later
-   */
-  use(fulfilled, rejected, options) {
-    this.handlers.push({
-      fulfilled,
-      rejected,
-      synchronous: options ? options.synchronous : false,
-      runWhen: options ? options.runWhen : null
-    });
-    return this.handlers.length - 1;
-  }
-  /**
-   * Remove an interceptor from the stack
-   *
-   * @param {Number} id The ID that was returned by `use`
-   *
-   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
-   */
-  eject(id) {
-    if (this.handlers[id]) {
-      this.handlers[id] = null;
-    }
-  }
-  /**
-   * Clear all interceptors from the stack
-   *
-   * @returns {void}
-   */
-  clear() {
-    if (this.handlers) {
-      this.handlers = [];
-    }
-  }
-  /**
-   * Iterate over all the registered interceptors
-   *
-   * This method is particularly useful for skipping over any
-   * interceptors that may have become `null` calling `eject`.
-   *
-   * @param {Function} fn The function to call for each interceptor
-   *
-   * @returns {void}
-   */
-  forEach(fn) {
-    utils.forEach(this.handlers, function forEachHandler(h) {
-      if (h !== null) {
-        fn(h);
-      }
-    });
-  }
+function isCancel(value) {
+  return !!(value && value.__CANCEL__);
 }
 export {
-  InterceptorManager as default
+  isCancel as default
 };
 //# sourceMappingURL=standards-sdk.es60.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es60.js","sources":["../../node_modules/axios/lib/core/InterceptorManager.js"],"sourcesContent":["'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n  constructor() {\n    this.handlers = [];\n  }\n\n  /**\n   * Add a new interceptor to the stack\n   *\n   * @param {Function} fulfilled The function to handle `then` for a `Promise`\n   * @param {Function} rejected The function to handle `reject` for a `Promise`\n   *\n   * @return {Number} An ID used to remove interceptor later\n   */\n  use(fulfilled, rejected, options) {\n    this.handlers.push({\n      fulfilled,\n      rejected,\n      synchronous: options ? options.synchronous : false,\n      runWhen: options ? options.runWhen : null\n    });\n    return this.handlers.length - 1;\n  }\n\n  /**\n   * Remove an interceptor from the stack\n   *\n   * @param {Number} id The ID that was returned by `use`\n   *\n   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise\n   */\n  eject(id) {\n    if (this.handlers[id]) {\n      this.handlers[id] = null;\n    }\n  }\n\n  /**\n   * Clear all interceptors from the stack\n   *\n   * @returns {void}\n   */\n  clear() {\n    if (this.handlers) {\n      this.handlers = [];\n    }\n  }\n\n  /**\n   * Iterate over all the registered interceptors\n   *\n   * This method is particularly useful for skipping over any\n   * interceptors that may have become `null` calling `eject`.\n   *\n   * @param {Function} fn The function to call for each interceptor\n   *\n   * @returns {void}\n   */\n  forEach(fn) {\n    utils.forEach(this.handlers, function forEachHandler(h) {\n      if (h !== null) {\n        fn(h);\n      }\n    });\n  }\n}\n\nexport default InterceptorManager;\n"],"names":[],"mappings":";AAIA,MAAM,mBAAmB;AAAA,EACvB,cAAc;AACZ,SAAK,WAAW,CAAE;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUE,IAAI,WAAW,UAAU,SAAS;AAChC,SAAK,SAAS,KAAK;AAAA,MACjB;AAAA,MACA;AAAA,MACA,aAAa,UAAU,QAAQ,cAAc;AAAA,MAC7C,SAAS,UAAU,QAAQ,UAAU;AAAA,IAC3C,CAAK;AACD,WAAO,KAAK,SAAS,SAAS;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASE,MAAM,IAAI;AACR,QAAI,KAAK,SAAS,EAAE,GAAG;AACrB,WAAK,SAAS,EAAE,IAAI;AAAA,IAC1B;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOE,QAAQ;AACN,QAAI,KAAK,UAAU;AACjB,WAAK,WAAW,CAAE;AAAA,IACxB;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYE,QAAQ,IAAI;AACV,UAAM,QAAQ,KAAK,UAAU,SAAS,eAAe,GAAG;AACtD,UAAI,MAAM,MAAM;AACd,WAAG,CAAC;AAAA,MACZ;AAAA,IACA,CAAK;AAAA,EACL;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es60.js","sources":["../../node_modules/axios/lib/cancel/isCancel.js"],"sourcesContent":["'use strict';\n\nexport default function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n}\n"],"names":[],"mappings":"AAEe,SAAS,SAAS,OAAO;AACtC,SAAO,CAAC,EAAE,SAAS,MAAM;AAC3B;","x_google_ignoreList":[0]}

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

@@ -1,53 +1,5 @@
-import transformData from "./standards-sdk.es76.js";
-import isCancel from "./standards-sdk.es43.js";
-import defaults from "./standards-sdk.es39.js";
-import CanceledError from "./standards-sdk.es41.js";
-import AxiosHeaders from "./standards-sdk.es49.js";
-import adapters from "./standards-sdk.es50.js";
-function throwIfCancellationRequested(config) {
-  if (config.cancelToken) {
-    config.cancelToken.throwIfRequested();
-  }
-  if (config.signal && config.signal.aborted) {
-    throw new CanceledError(null, config);
-  }
-}
-function dispatchRequest(config) {
-  throwIfCancellationRequested(config);
-  config.headers = AxiosHeaders.from(config.headers);
-  config.data = transformData.call(
-    config,
-    config.transformRequest
-  );
-  if (["post", "put", "patch"].indexOf(config.method) !== -1) {
-    config.headers.setContentType("application/x-www-form-urlencoded", false);
-  }
-  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);
-  return adapter(config).then(function onAdapterResolution(response) {
-    throwIfCancellationRequested(config);
-    response.data = transformData.call(
-      config,
-      config.transformResponse,
-      response
-    );
-    response.headers = AxiosHeaders.from(response.headers);
-    return response;
-  }, function onAdapterRejection(reason) {
-    if (!isCancel(reason)) {
-      throwIfCancellationRequested(config);
-      if (reason && reason.response) {
-        reason.response.data = transformData.call(
-          config,
-          config.transformResponse,
-          reason.response
-        );
-        reason.response.headers = AxiosHeaders.from(reason.response.headers);
-      }
-    }
-    return Promise.reject(reason);
-  });
-}
+const VERSION = "1.8.4";
 export {
-  dispatchRequest as default
+  VERSION
 };
 //# sourceMappingURL=standards-sdk.es61.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es61.js","sources":["../../node_modules/axios/lib/core/dispatchRequest.js"],"sourcesContent":["'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError(null, config);\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  config.headers = AxiosHeaders.from(config.headers);\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.transformRequest\n  );\n\n  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n    config.headers.setContentType('application/x-www-form-urlencoded', false);\n  }\n\n  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      config.transformResponse,\n      response\n    );\n\n    response.headers = AxiosHeaders.from(response.headers);\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          config.transformResponse,\n          reason.response\n        );\n        reason.response.headers = AxiosHeaders.from(reason.response.headers);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n}\n"],"names":[],"mappings":";;;;;;AAgBA,SAAS,6BAA6B,QAAQ;AAC5C,MAAI,OAAO,aAAa;AACtB,WAAO,YAAY,iBAAkB;AAAA,EACzC;AAEE,MAAI,OAAO,UAAU,OAAO,OAAO,SAAS;AAC1C,UAAM,IAAI,cAAc,MAAM,MAAM;AAAA,EACxC;AACA;AASe,SAAS,gBAAgB,QAAQ;AAC9C,+BAA6B,MAAM;AAEnC,SAAO,UAAU,aAAa,KAAK,OAAO,OAAO;AAGjD,SAAO,OAAO,cAAc;AAAA,IAC1B;AAAA,IACA,OAAO;AAAA,EACR;AAED,MAAI,CAAC,QAAQ,OAAO,OAAO,EAAE,QAAQ,OAAO,MAAM,MAAM,IAAI;AAC1D,WAAO,QAAQ,eAAe,qCAAqC,KAAK;AAAA,EAC5E;AAEE,QAAM,UAAU,SAAS,WAAW,OAAO,WAAW,SAAS,OAAO;AAEtE,SAAO,QAAQ,MAAM,EAAE,KAAK,SAAS,oBAAoB,UAAU;AACjE,iCAA6B,MAAM;AAGnC,aAAS,OAAO,cAAc;AAAA,MAC5B;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IACD;AAED,aAAS,UAAU,aAAa,KAAK,SAAS,OAAO;AAErD,WAAO;AAAA,EACX,GAAK,SAAS,mBAAmB,QAAQ;AACrC,QAAI,CAAC,SAAS,MAAM,GAAG;AACrB,mCAA6B,MAAM;AAGnC,UAAI,UAAU,OAAO,UAAU;AAC7B,eAAO,SAAS,OAAO,cAAc;AAAA,UACnC;AAAA,UACA,OAAO;AAAA,UACP,OAAO;AAAA,QACR;AACD,eAAO,SAAS,UAAU,aAAa,KAAK,OAAO,SAAS,OAAO;AAAA,MAC3E;AAAA,IACA;AAEI,WAAO,QAAQ,OAAO,MAAM;AAAA,EAChC,CAAG;AACH;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es61.js","sources":["../../node_modules/axios/lib/env/data.js"],"sourcesContent":["export const VERSION = \"1.8.4\";"],"names":[],"mappings":"AAAY,MAAC,UAAU;","x_google_ignoreList":[0]}