@jentic/arazzo-parser 1.0.0-alpha.10 → 1.0.0-alpha.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4982,7 +4982,6 @@ class ArazzoSpecification1 extends _speclynx_apidom_datamodel__WEBPACK_IMPORTED_
4982
4982
  super(content, meta, attributes);
4983
4983
  this.element = 'arazzoSpecification1';
4984
4984
  this.classes.push('api');
4985
- this.classes.push('arazzo');
4986
4985
  }
4987
4986
  get arazzo() {
4988
4987
  return this.get('arazzo');
@@ -34934,7 +34933,8 @@ const analyze = async source => {
34934
34933
  if (parser === null && parserInitLock === null) {
34935
34934
  // acquire lock
34936
34935
  parserInitLock = web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Parser.init({
34937
- wasmBinary: treeSitter
34936
+ wasmBinary: treeSitter,
34937
+ locateFile: scriptName => scriptName
34938
34938
  }).then(() => web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Language.load(treeSitterJson)).then(jsonLanguage => {
34939
34939
  const parserInstance = new web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Parser();
34940
34940
  parserInstance.setLanguage(jsonLanguage);
@@ -39904,7 +39904,8 @@ const analyze = async source => {
39904
39904
  if (parser === null && parserInitLock === null) {
39905
39905
  // acquire lock
39906
39906
  parserInitLock = web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Parser.init({
39907
- wasmBinary: treeSitter
39907
+ wasmBinary: treeSitter,
39908
+ locateFile: scriptName => scriptName
39908
39909
  }).then(() => web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Language.load(treeSitterYaml)).then(yamlLanguage => {
39909
39910
  const parserInstance = new web_tree_sitter__WEBPACK_IMPORTED_MODULE_0__.Parser();
39910
39911
  parserInstance.setLanguage(yamlLanguage);
@@ -56270,14 +56271,14 @@ const factory = (env) => {
56270
56271
 
56271
56272
  if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
56272
56273
  throw Object.assign(
56273
- new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Network Error', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NETWORK, config, request),
56274
+ new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Network Error', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NETWORK, config, request, err && err.response),
56274
56275
  {
56275
56276
  cause: err.cause || err
56276
56277
  }
56277
56278
  )
56278
56279
  }
56279
56280
 
56280
- throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].from(err, err && err.code, config, request);
56281
+ throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].from(err, err && err.code, config, request, err && err.response);
56281
56282
  }
56282
56283
  }
56283
56284
  }
@@ -56869,6 +56870,8 @@ __webpack_require__.r(__webpack_exports__);
56869
56870
  /* harmony import */ var _buildFullPath_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(22921);
56870
56871
  /* harmony import */ var _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62215);
56871
56872
  /* harmony import */ var _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(76487);
56873
+ /* harmony import */ var _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(69006);
56874
+
56872
56875
 
56873
56876
 
56874
56877
 
@@ -56951,7 +56954,8 @@ class Axios {
56951
56954
  _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__["default"].assertOptions(transitional, {
56952
56955
  silentJSONParsing: validators.transitional(validators.boolean),
56953
56956
  forcedJSONParsing: validators.transitional(validators.boolean),
56954
- clarifyTimeoutError: validators.transitional(validators.boolean)
56957
+ clarifyTimeoutError: validators.transitional(validators.boolean),
56958
+ legacyInterceptorReqResOrdering: validators.transitional(validators.boolean)
56955
56959
  }, false);
56956
56960
  }
56957
56961
 
@@ -57010,7 +57014,14 @@ class Axios {
57010
57014
 
57011
57015
  synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
57012
57016
 
57013
- requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
57017
+ const transitional = config.transitional || _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_8__["default"];
57018
+ const legacyInterceptorReqResOrdering = transitional && transitional.legacyInterceptorReqResOrdering;
57019
+
57020
+ if (legacyInterceptorReqResOrdering) {
57021
+ requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
57022
+ } else {
57023
+ requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
57024
+ }
57014
57025
  });
57015
57026
 
57016
57027
  const responseInterceptorChain = [];
@@ -57030,13 +57041,8 @@ class Axios {
57030
57041
 
57031
57042
  promise = Promise.resolve(config);
57032
57043
 
57033
- let prevResult = config;
57034
57044
  while (i < len) {
57035
- promise = promise
57036
- .then(chain[i++])
57037
- .then(result => { prevResult = result !== undefined ? result : prevResult })
57038
- .catch(chain[i++])
57039
- .then(() => prevResult);
57045
+ promise = promise.then(chain[i++], chain[i++]);
57040
57046
  }
57041
57047
 
57042
57048
  return promise;
@@ -57067,7 +57073,7 @@ class Axios {
57067
57073
  len = responseInterceptorChain.length;
57068
57074
 
57069
57075
  while (i < len) {
57070
- promise = promise.then(responseInterceptorChain[i++]).catch(responseInterceptorChain[i++]);
57076
+ promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
57071
57077
  }
57072
57078
 
57073
57079
  return promise;
@@ -57767,7 +57773,8 @@ __webpack_require__.r(__webpack_exports__);
57767
57773
 
57768
57774
 
57769
57775
 
57770
- const headersToObject = (thing) => thing instanceof _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"] ? { ...thing } : thing;
57776
+ const headersToObject = (thing) =>
57777
+ thing instanceof _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"] ? { ...thing } : thing;
57771
57778
 
57772
57779
  /**
57773
57780
  * Config-specific merge-function which creates a new config-object
@@ -57856,14 +57863,27 @@ function mergeConfig(config1, config2) {
57856
57863
  socketPath: defaultToConfig2,
57857
57864
  responseEncoding: defaultToConfig2,
57858
57865
  validateStatus: mergeDirectKeys,
57859
- headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
57866
+ headers: (a, b, prop) =>
57867
+ mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true),
57860
57868
  };
57861
57869
 
57862
- _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
57863
- const merge = mergeMap[prop] || mergeDeepProperties;
57864
- const configValue = merge(config1[prop], config2[prop], prop);
57865
- (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
57866
- });
57870
+ _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(
57871
+ Object.keys({ ...config1, ...config2 }),
57872
+ function computeConfigValue(prop) {
57873
+ if (
57874
+ prop === "__proto__" ||
57875
+ prop === "constructor" ||
57876
+ prop === "prototype"
57877
+ )
57878
+ return;
57879
+ const merge = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasOwnProp(mergeMap, prop)
57880
+ ? mergeMap[prop]
57881
+ : mergeDeepProperties;
57882
+ const configValue = merge(config1[prop], config2[prop], prop);
57883
+ (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(configValue) && merge !== mergeDirectKeys) ||
57884
+ (config[prop] = configValue);
57885
+ },
57886
+ );
57867
57887
 
57868
57888
  return config;
57869
57889
  }
@@ -58147,7 +58167,8 @@ __webpack_require__.r(__webpack_exports__);
58147
58167
  /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
58148
58168
  silentJSONParsing: true,
58149
58169
  forcedJSONParsing: true,
58150
- clarifyTimeoutError: false
58170
+ clarifyTimeoutError: false,
58171
+ legacyInterceptorReqResOrdering: true
58151
58172
  });
58152
58173
 
58153
58174
 
@@ -58161,7 +58182,7 @@ __webpack_require__.r(__webpack_exports__);
58161
58182
  /* harmony export */ __webpack_require__.d(__webpack_exports__, {
58162
58183
  /* harmony export */ VERSION: () => (/* binding */ VERSION)
58163
58184
  /* harmony export */ });
58164
- const VERSION = "1.13.3";
58185
+ const VERSION = "1.13.5";
58165
58186
 
58166
58187
  /***/ },
58167
58188
 
@@ -58715,10 +58736,15 @@ function isAbsoluteURL(url) {
58715
58736
  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
58716
58737
  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
58717
58738
  // by any combination of letters, digits, plus, period, or hyphen.
58739
+ if (typeof url !== 'string') {
58740
+ return false;
58741
+ }
58742
+
58718
58743
  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
58719
58744
  }
58720
58745
 
58721
58746
 
58747
+
58722
58748
  /***/ },
58723
58749
 
58724
58750
  /***/ 75757
@@ -59838,30 +59864,30 @@ __webpack_require__.r(__webpack_exports__);
59838
59864
 
59839
59865
  // utils is a library of generic helper functions non-specific to axios
59840
59866
 
59841
- const {toString} = Object.prototype;
59842
- const {getPrototypeOf} = Object;
59843
- const {iterator, toStringTag} = Symbol;
59867
+ const { toString } = Object.prototype;
59868
+ const { getPrototypeOf } = Object;
59869
+ const { iterator, toStringTag } = Symbol;
59844
59870
 
59845
- const kindOf = (cache => thing => {
59846
- const str = toString.call(thing);
59847
- return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
59871
+ const kindOf = ((cache) => (thing) => {
59872
+ const str = toString.call(thing);
59873
+ return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
59848
59874
  })(Object.create(null));
59849
59875
 
59850
59876
  const kindOfTest = (type) => {
59851
59877
  type = type.toLowerCase();
59852
- return (thing) => kindOf(thing) === type
59853
- }
59878
+ return (thing) => kindOf(thing) === type;
59879
+ };
59854
59880
 
59855
- const typeOfTest = type => thing => typeof thing === type;
59881
+ const typeOfTest = (type) => (thing) => typeof thing === type;
59856
59882
 
59857
59883
  /**
59858
- * Determine if a value is an Array
59884
+ * Determine if a value is a non-null object
59859
59885
  *
59860
59886
  * @param {Object} val The value to test
59861
59887
  *
59862
59888
  * @returns {boolean} True if value is an Array, otherwise false
59863
59889
  */
59864
- const {isArray} = Array;
59890
+ const { isArray } = Array;
59865
59891
 
59866
59892
  /**
59867
59893
  * Determine if a value is undefined
@@ -59870,7 +59896,7 @@ const {isArray} = Array;
59870
59896
  *
59871
59897
  * @returns {boolean} True if the value is undefined, otherwise false
59872
59898
  */
59873
- const isUndefined = typeOfTest('undefined');
59899
+ const isUndefined = typeOfTest("undefined");
59874
59900
 
59875
59901
  /**
59876
59902
  * Determine if a value is a Buffer
@@ -59880,8 +59906,14 @@ const isUndefined = typeOfTest('undefined');
59880
59906
  * @returns {boolean} True if value is a Buffer, otherwise false
59881
59907
  */
59882
59908
  function isBuffer(val) {
59883
- return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
59884
- && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
59909
+ return (
59910
+ val !== null &&
59911
+ !isUndefined(val) &&
59912
+ val.constructor !== null &&
59913
+ !isUndefined(val.constructor) &&
59914
+ isFunction(val.constructor.isBuffer) &&
59915
+ val.constructor.isBuffer(val)
59916
+ );
59885
59917
  }
59886
59918
 
59887
59919
  /**
@@ -59891,8 +59923,7 @@ function isBuffer(val) {
59891
59923
  *
59892
59924
  * @returns {boolean} True if value is an ArrayBuffer, otherwise false
59893
59925
  */
59894
- const isArrayBuffer = kindOfTest('ArrayBuffer');
59895
-
59926
+ const isArrayBuffer = kindOfTest("ArrayBuffer");
59896
59927
 
59897
59928
  /**
59898
59929
  * Determine if a value is a view on an ArrayBuffer
@@ -59903,10 +59934,10 @@ const isArrayBuffer = kindOfTest('ArrayBuffer');
59903
59934
  */
59904
59935
  function isArrayBufferView(val) {
59905
59936
  let result;
59906
- if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
59937
+ if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
59907
59938
  result = ArrayBuffer.isView(val);
59908
59939
  } else {
59909
- result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
59940
+ result = val && val.buffer && isArrayBuffer(val.buffer);
59910
59941
  }
59911
59942
  return result;
59912
59943
  }
@@ -59918,7 +59949,7 @@ function isArrayBufferView(val) {
59918
59949
  *
59919
59950
  * @returns {boolean} True if value is a String, otherwise false
59920
59951
  */
59921
- const isString = typeOfTest('string');
59952
+ const isString = typeOfTest("string");
59922
59953
 
59923
59954
  /**
59924
59955
  * Determine if a value is a Function
@@ -59926,7 +59957,7 @@ const isString = typeOfTest('string');
59926
59957
  * @param {*} val The value to test
59927
59958
  * @returns {boolean} True if value is a Function, otherwise false
59928
59959
  */
59929
- const isFunction = typeOfTest('function');
59960
+ const isFunction = typeOfTest("function");
59930
59961
 
59931
59962
  /**
59932
59963
  * Determine if a value is a Number
@@ -59935,7 +59966,7 @@ const isFunction = typeOfTest('function');
59935
59966
  *
59936
59967
  * @returns {boolean} True if value is a Number, otherwise false
59937
59968
  */
59938
- const isNumber = typeOfTest('number');
59969
+ const isNumber = typeOfTest("number");
59939
59970
 
59940
59971
  /**
59941
59972
  * Determine if a value is an Object
@@ -59944,7 +59975,7 @@ const isNumber = typeOfTest('number');
59944
59975
  *
59945
59976
  * @returns {boolean} True if value is an Object, otherwise false
59946
59977
  */
59947
- const isObject = (thing) => thing !== null && typeof thing === 'object';
59978
+ const isObject = (thing) => thing !== null && typeof thing === "object";
59948
59979
 
59949
59980
  /**
59950
59981
  * Determine if a value is a Boolean
@@ -59952,7 +59983,7 @@ const isObject = (thing) => thing !== null && typeof thing === 'object';
59952
59983
  * @param {*} thing The value to test
59953
59984
  * @returns {boolean} True if value is a Boolean, otherwise false
59954
59985
  */
59955
- const isBoolean = thing => thing === true || thing === false;
59986
+ const isBoolean = (thing) => thing === true || thing === false;
59956
59987
 
59957
59988
  /**
59958
59989
  * Determine if a value is a plain Object
@@ -59962,13 +59993,19 @@ const isBoolean = thing => thing === true || thing === false;
59962
59993
  * @returns {boolean} True if value is a plain Object, otherwise false
59963
59994
  */
59964
59995
  const isPlainObject = (val) => {
59965
- if (kindOf(val) !== 'object') {
59996
+ if (kindOf(val) !== "object") {
59966
59997
  return false;
59967
59998
  }
59968
59999
 
59969
60000
  const prototype = getPrototypeOf(val);
59970
- return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
59971
- }
60001
+ return (
60002
+ (prototype === null ||
60003
+ prototype === Object.prototype ||
60004
+ Object.getPrototypeOf(prototype) === null) &&
60005
+ !(toStringTag in val) &&
60006
+ !(iterator in val)
60007
+ );
60008
+ };
59972
60009
 
59973
60010
  /**
59974
60011
  * Determine if a value is an empty object (safely handles Buffers)
@@ -59984,12 +60021,15 @@ const isEmptyObject = (val) => {
59984
60021
  }
59985
60022
 
59986
60023
  try {
59987
- return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
60024
+ return (
60025
+ Object.keys(val).length === 0 &&
60026
+ Object.getPrototypeOf(val) === Object.prototype
60027
+ );
59988
60028
  } catch (e) {
59989
60029
  // Fallback for any other objects that might cause RangeError with Object.keys()
59990
60030
  return false;
59991
60031
  }
59992
- }
60032
+ };
59993
60033
 
59994
60034
  /**
59995
60035
  * Determine if a value is a Date
@@ -59998,7 +60038,7 @@ const isEmptyObject = (val) => {
59998
60038
  *
59999
60039
  * @returns {boolean} True if value is a Date, otherwise false
60000
60040
  */
60001
- const isDate = kindOfTest('Date');
60041
+ const isDate = kindOfTest("Date");
60002
60042
 
60003
60043
  /**
60004
60044
  * Determine if a value is a File
@@ -60007,7 +60047,7 @@ const isDate = kindOfTest('Date');
60007
60047
  *
60008
60048
  * @returns {boolean} True if value is a File, otherwise false
60009
60049
  */
60010
- const isFile = kindOfTest('File');
60050
+ const isFile = kindOfTest("File");
60011
60051
 
60012
60052
  /**
60013
60053
  * Determine if a value is a Blob
@@ -60016,7 +60056,7 @@ const isFile = kindOfTest('File');
60016
60056
  *
60017
60057
  * @returns {boolean} True if value is a Blob, otherwise false
60018
60058
  */
60019
- const isBlob = kindOfTest('Blob');
60059
+ const isBlob = kindOfTest("Blob");
60020
60060
 
60021
60061
  /**
60022
60062
  * Determine if a value is a FileList
@@ -60025,7 +60065,7 @@ const isBlob = kindOfTest('Blob');
60025
60065
  *
60026
60066
  * @returns {boolean} True if value is a File, otherwise false
60027
60067
  */
60028
- const isFileList = kindOfTest('FileList');
60068
+ const isFileList = kindOfTest("FileList");
60029
60069
 
60030
60070
  /**
60031
60071
  * Determine if a value is a Stream
@@ -60045,16 +60085,17 @@ const isStream = (val) => isObject(val) && isFunction(val.pipe);
60045
60085
  */
60046
60086
  const isFormData = (thing) => {
60047
60087
  let kind;
60048
- return thing && (
60049
- (typeof FormData === 'function' && thing instanceof FormData) || (
60050
- isFunction(thing.append) && (
60051
- (kind = kindOf(thing)) === 'formdata' ||
60052
- // detect form-data instance
60053
- (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
60054
- )
60055
- )
60056
- )
60057
- }
60088
+ return (
60089
+ thing &&
60090
+ ((typeof FormData === "function" && thing instanceof FormData) ||
60091
+ (isFunction(thing.append) &&
60092
+ ((kind = kindOf(thing)) === "formdata" ||
60093
+ // detect form-data instance
60094
+ (kind === "object" &&
60095
+ isFunction(thing.toString) &&
60096
+ thing.toString() === "[object FormData]"))))
60097
+ );
60098
+ };
60058
60099
 
60059
60100
  /**
60060
60101
  * Determine if a value is a URLSearchParams object
@@ -60063,9 +60104,14 @@ const isFormData = (thing) => {
60063
60104
  *
60064
60105
  * @returns {boolean} True if value is a URLSearchParams object, otherwise false
60065
60106
  */
60066
- const isURLSearchParams = kindOfTest('URLSearchParams');
60107
+ const isURLSearchParams = kindOfTest("URLSearchParams");
60067
60108
 
60068
- const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);
60109
+ const [isReadableStream, isRequest, isResponse, isHeaders] = [
60110
+ "ReadableStream",
60111
+ "Request",
60112
+ "Response",
60113
+ "Headers",
60114
+ ].map(kindOfTest);
60069
60115
 
60070
60116
  /**
60071
60117
  * Trim excess whitespace off the beginning and end of a string
@@ -60074,8 +60120,8 @@ const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream',
60074
60120
  *
60075
60121
  * @returns {String} The String freed of excess whitespace
60076
60122
  */
60077
- const trim = (str) => str.trim ?
60078
- str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
60123
+ const trim = (str) =>
60124
+ str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
60079
60125
 
60080
60126
  /**
60081
60127
  * Iterate over an Array or an Object invoking a function for each item.
@@ -60093,9 +60139,9 @@ const trim = (str) => str.trim ?
60093
60139
  * @param {Boolean} [options.allOwnKeys = false]
60094
60140
  * @returns {any}
60095
60141
  */
60096
- function forEach(obj, fn, {allOwnKeys = false} = {}) {
60142
+ function forEach(obj, fn, { allOwnKeys = false } = {}) {
60097
60143
  // Don't bother if no value provided
60098
- if (obj === null || typeof obj === 'undefined') {
60144
+ if (obj === null || typeof obj === "undefined") {
60099
60145
  return;
60100
60146
  }
60101
60147
 
@@ -60103,7 +60149,7 @@ function forEach(obj, fn, {allOwnKeys = false} = {}) {
60103
60149
  let l;
60104
60150
 
60105
60151
  // Force an array if not already something iterable
60106
- if (typeof obj !== 'object') {
60152
+ if (typeof obj !== "object") {
60107
60153
  /*eslint no-param-reassign:0*/
60108
60154
  obj = [obj];
60109
60155
  }
@@ -60120,7 +60166,9 @@ function forEach(obj, fn, {allOwnKeys = false} = {}) {
60120
60166
  }
60121
60167
 
60122
60168
  // Iterate over object keys
60123
- const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
60169
+ const keys = allOwnKeys
60170
+ ? Object.getOwnPropertyNames(obj)
60171
+ : Object.keys(obj);
60124
60172
  const len = keys.length;
60125
60173
  let key;
60126
60174
 
@@ -60132,7 +60180,7 @@ function forEach(obj, fn, {allOwnKeys = false} = {}) {
60132
60180
  }
60133
60181
 
60134
60182
  function findKey(obj, key) {
60135
- if (isBuffer(obj)){
60183
+ if (isBuffer(obj)) {
60136
60184
  return null;
60137
60185
  }
60138
60186
 
@@ -60152,10 +60200,15 @@ function findKey(obj, key) {
60152
60200
  const _global = (() => {
60153
60201
  /*eslint no-undef:0*/
60154
60202
  if (typeof globalThis !== "undefined") return globalThis;
60155
- return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : __webpack_require__.g)
60203
+ return typeof self !== "undefined"
60204
+ ? self
60205
+ : typeof window !== "undefined"
60206
+ ? window
60207
+ : __webpack_require__.g;
60156
60208
  })();
60157
60209
 
60158
- const isContextDefined = (context) => !isUndefined(context) && context !== _global;
60210
+ const isContextDefined = (context) =>
60211
+ !isUndefined(context) && context !== _global;
60159
60212
 
60160
60213
  /**
60161
60214
  * Accepts varargs expecting each argument to be an object, then
@@ -60176,10 +60229,15 @@ const isContextDefined = (context) => !isUndefined(context) && context !== _glob
60176
60229
  * @returns {Object} Result of all merge properties
60177
60230
  */
60178
60231
  function merge(/* obj1, obj2, obj3, ... */) {
60179
- const {caseless, skipUndefined} = isContextDefined(this) && this || {};
60232
+ const { caseless, skipUndefined } = (isContextDefined(this) && this) || {};
60180
60233
  const result = {};
60181
60234
  const assignValue = (val, key) => {
60182
- const targetKey = caseless && findKey(result, key) || key;
60235
+ // Skip dangerous property names to prevent prototype pollution
60236
+ if (key === "__proto__" || key === "constructor" || key === "prototype") {
60237
+ return;
60238
+ }
60239
+
60240
+ const targetKey = (caseless && findKey(result, key)) || key;
60183
60241
  if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
60184
60242
  result[targetKey] = merge(result[targetKey], val);
60185
60243
  } else if (isPlainObject(val)) {
@@ -60189,7 +60247,7 @@ function merge(/* obj1, obj2, obj3, ... */) {
60189
60247
  } else if (!skipUndefined || !isUndefined(val)) {
60190
60248
  result[targetKey] = val;
60191
60249
  }
60192
- }
60250
+ };
60193
60251
 
60194
60252
  for (let i = 0, l = arguments.length; i < l; i++) {
60195
60253
  arguments[i] && forEach(arguments[i], assignValue);
@@ -60208,26 +60266,30 @@ function merge(/* obj1, obj2, obj3, ... */) {
60208
60266
  * @param {Boolean} [options.allOwnKeys]
60209
60267
  * @returns {Object} The resulting value of object a
60210
60268
  */
60211
- const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
60212
- forEach(b, (val, key) => {
60213
- if (thisArg && isFunction(val)) {
60214
- Object.defineProperty(a, key, {
60215
- value: (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__["default"])(val, thisArg),
60216
- writable: true,
60217
- enumerable: true,
60218
- configurable: true
60219
- });
60220
- } else {
60221
- Object.defineProperty(a, key, {
60222
- value: val,
60223
- writable: true,
60224
- enumerable: true,
60225
- configurable: true
60226
- });
60227
- }
60228
- }, {allOwnKeys});
60269
+ const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
60270
+ forEach(
60271
+ b,
60272
+ (val, key) => {
60273
+ if (thisArg && isFunction(val)) {
60274
+ Object.defineProperty(a, key, {
60275
+ value: (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__["default"])(val, thisArg),
60276
+ writable: true,
60277
+ enumerable: true,
60278
+ configurable: true,
60279
+ });
60280
+ } else {
60281
+ Object.defineProperty(a, key, {
60282
+ value: val,
60283
+ writable: true,
60284
+ enumerable: true,
60285
+ configurable: true,
60286
+ });
60287
+ }
60288
+ },
60289
+ { allOwnKeys },
60290
+ );
60229
60291
  return a;
60230
- }
60292
+ };
60231
60293
 
60232
60294
  /**
60233
60295
  * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
@@ -60237,11 +60299,11 @@ const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
60237
60299
  * @returns {string} content value without BOM
60238
60300
  */
60239
60301
  const stripBOM = (content) => {
60240
- if (content.charCodeAt(0) === 0xFEFF) {
60302
+ if (content.charCodeAt(0) === 0xfeff) {
60241
60303
  content = content.slice(1);
60242
60304
  }
60243
60305
  return content;
60244
- }
60306
+ };
60245
60307
 
60246
60308
  /**
60247
60309
  * Inherit the prototype methods from one constructor into another
@@ -60253,18 +60315,21 @@ const stripBOM = (content) => {
60253
60315
  * @returns {void}
60254
60316
  */
60255
60317
  const inherits = (constructor, superConstructor, props, descriptors) => {
60256
- constructor.prototype = Object.create(superConstructor.prototype, descriptors);
60257
- Object.defineProperty(constructor.prototype, 'constructor', {
60318
+ constructor.prototype = Object.create(
60319
+ superConstructor.prototype,
60320
+ descriptors,
60321
+ );
60322
+ Object.defineProperty(constructor.prototype, "constructor", {
60258
60323
  value: constructor,
60259
60324
  writable: true,
60260
60325
  enumerable: false,
60261
- configurable: true
60326
+ configurable: true,
60262
60327
  });
60263
- Object.defineProperty(constructor, 'super', {
60264
- value: superConstructor.prototype
60328
+ Object.defineProperty(constructor, "super", {
60329
+ value: superConstructor.prototype,
60265
60330
  });
60266
60331
  props && Object.assign(constructor.prototype, props);
60267
- }
60332
+ };
60268
60333
 
60269
60334
  /**
60270
60335
  * Resolve object with deep prototype chain to a flat object
@@ -60290,16 +60355,23 @@ const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
60290
60355
  i = props.length;
60291
60356
  while (i-- > 0) {
60292
60357
  prop = props[i];
60293
- if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
60358
+ if (
60359
+ (!propFilter || propFilter(prop, sourceObj, destObj)) &&
60360
+ !merged[prop]
60361
+ ) {
60294
60362
  destObj[prop] = sourceObj[prop];
60295
60363
  merged[prop] = true;
60296
60364
  }
60297
60365
  }
60298
60366
  sourceObj = filter !== false && getPrototypeOf(sourceObj);
60299
- } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
60367
+ } while (
60368
+ sourceObj &&
60369
+ (!filter || filter(sourceObj, destObj)) &&
60370
+ sourceObj !== Object.prototype
60371
+ );
60300
60372
 
60301
60373
  return destObj;
60302
- }
60374
+ };
60303
60375
 
60304
60376
  /**
60305
60377
  * Determines whether a string ends with the characters of a specified string
@@ -60318,8 +60390,7 @@ const endsWith = (str, searchString, position) => {
60318
60390
  position -= searchString.length;
60319
60391
  const lastIndex = str.indexOf(searchString, position);
60320
60392
  return lastIndex !== -1 && lastIndex === position;
60321
- }
60322
-
60393
+ };
60323
60394
 
60324
60395
  /**
60325
60396
  * Returns new array from array like object or null if failed
@@ -60338,7 +60409,7 @@ const toArray = (thing) => {
60338
60409
  arr[i] = thing[i];
60339
60410
  }
60340
60411
  return arr;
60341
- }
60412
+ };
60342
60413
 
60343
60414
  /**
60344
60415
  * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
@@ -60349,12 +60420,12 @@ const toArray = (thing) => {
60349
60420
  * @returns {Array}
60350
60421
  */
60351
60422
  // eslint-disable-next-line func-names
60352
- const isTypedArray = (TypedArray => {
60423
+ const isTypedArray = ((TypedArray) => {
60353
60424
  // eslint-disable-next-line func-names
60354
- return thing => {
60425
+ return (thing) => {
60355
60426
  return TypedArray && thing instanceof TypedArray;
60356
60427
  };
60357
- })(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
60428
+ })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
60358
60429
 
60359
60430
  /**
60360
60431
  * For each entry in the object, call the function with the key and value.
@@ -60375,7 +60446,7 @@ const forEachEntry = (obj, fn) => {
60375
60446
  const pair = result.value;
60376
60447
  fn.call(obj, pair[0], pair[1]);
60377
60448
  }
60378
- }
60449
+ };
60379
60450
 
60380
60451
  /**
60381
60452
  * It takes a regular expression and a string, and returns an array of all the matches
@@ -60394,21 +60465,25 @@ const matchAll = (regExp, str) => {
60394
60465
  }
60395
60466
 
60396
60467
  return arr;
60397
- }
60468
+ };
60398
60469
 
60399
60470
  /* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
60400
- const isHTMLForm = kindOfTest('HTMLFormElement');
60471
+ const isHTMLForm = kindOfTest("HTMLFormElement");
60401
60472
 
60402
- const toCamelCase = str => {
60403
- return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
60404
- function replacer(m, p1, p2) {
60473
+ const toCamelCase = (str) => {
60474
+ return str
60475
+ .toLowerCase()
60476
+ .replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
60405
60477
  return p1.toUpperCase() + p2;
60406
- }
60407
- );
60478
+ });
60408
60479
  };
60409
60480
 
60410
60481
  /* Creating a function that will check if an object has a property. */
60411
- const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
60482
+ const hasOwnProperty = (
60483
+ ({ hasOwnProperty }) =>
60484
+ (obj, prop) =>
60485
+ hasOwnProperty.call(obj, prop)
60486
+ )(Object.prototype);
60412
60487
 
60413
60488
  /**
60414
60489
  * Determine if a value is a RegExp object
@@ -60417,7 +60492,7 @@ const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call
60417
60492
  *
60418
60493
  * @returns {boolean} True if value is a RegExp object, otherwise false
60419
60494
  */
60420
- const isRegExp = kindOfTest('RegExp');
60495
+ const isRegExp = kindOfTest("RegExp");
60421
60496
 
60422
60497
  const reduceDescriptors = (obj, reducer) => {
60423
60498
  const descriptors = Object.getOwnPropertyDescriptors(obj);
@@ -60431,7 +60506,7 @@ const reduceDescriptors = (obj, reducer) => {
60431
60506
  });
60432
60507
 
60433
60508
  Object.defineProperties(obj, reducedDescriptors);
60434
- }
60509
+ };
60435
60510
 
60436
60511
  /**
60437
60512
  * Makes all methods read-only
@@ -60441,7 +60516,10 @@ const reduceDescriptors = (obj, reducer) => {
60441
60516
  const freezeMethods = (obj) => {
60442
60517
  reduceDescriptors(obj, (descriptor, name) => {
60443
60518
  // skip restricted props in strict mode
60444
- if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
60519
+ if (
60520
+ isFunction(obj) &&
60521
+ ["arguments", "caller", "callee"].indexOf(name) !== -1
60522
+ ) {
60445
60523
  return false;
60446
60524
  }
60447
60525
 
@@ -60451,40 +60529,42 @@ const freezeMethods = (obj) => {
60451
60529
 
60452
60530
  descriptor.enumerable = false;
60453
60531
 
60454
- if ('writable' in descriptor) {
60532
+ if ("writable" in descriptor) {
60455
60533
  descriptor.writable = false;
60456
60534
  return;
60457
60535
  }
60458
60536
 
60459
60537
  if (!descriptor.set) {
60460
60538
  descriptor.set = () => {
60461
- throw Error('Can not rewrite read-only method \'' + name + '\'');
60539
+ throw Error("Can not rewrite read-only method '" + name + "'");
60462
60540
  };
60463
60541
  }
60464
60542
  });
60465
- }
60543
+ };
60466
60544
 
60467
60545
  const toObjectSet = (arrayOrString, delimiter) => {
60468
60546
  const obj = {};
60469
60547
 
60470
60548
  const define = (arr) => {
60471
- arr.forEach(value => {
60549
+ arr.forEach((value) => {
60472
60550
  obj[value] = true;
60473
60551
  });
60474
- }
60552
+ };
60475
60553
 
60476
- isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
60554
+ isArray(arrayOrString)
60555
+ ? define(arrayOrString)
60556
+ : define(String(arrayOrString).split(delimiter));
60477
60557
 
60478
60558
  return obj;
60479
- }
60559
+ };
60480
60560
 
60481
- const noop = () => {}
60561
+ const noop = () => {};
60482
60562
 
60483
60563
  const toFiniteNumber = (value, defaultValue) => {
60484
- return value != null && Number.isFinite(value = +value) ? value : defaultValue;
60485
- }
60486
-
60487
-
60564
+ return value != null && Number.isFinite((value = +value))
60565
+ ? value
60566
+ : defaultValue;
60567
+ };
60488
60568
 
60489
60569
  /**
60490
60570
  * If the thing is a FormData object, return true, otherwise return false.
@@ -60494,14 +60574,18 @@ const toFiniteNumber = (value, defaultValue) => {
60494
60574
  * @returns {boolean}
60495
60575
  */
60496
60576
  function isSpecCompliantForm(thing) {
60497
- return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
60577
+ return !!(
60578
+ thing &&
60579
+ isFunction(thing.append) &&
60580
+ thing[toStringTag] === "FormData" &&
60581
+ thing[iterator]
60582
+ );
60498
60583
  }
60499
60584
 
60500
60585
  const toJSONObject = (obj) => {
60501
60586
  const stack = new Array(10);
60502
60587
 
60503
60588
  const visit = (source, i) => {
60504
-
60505
60589
  if (isObject(source)) {
60506
60590
  if (stack.indexOf(source) >= 0) {
60507
60591
  return;
@@ -60512,7 +60596,7 @@ const toJSONObject = (obj) => {
60512
60596
  return source;
60513
60597
  }
60514
60598
 
60515
- if(!('toJSON' in source)) {
60599
+ if (!("toJSON" in source)) {
60516
60600
  stack[i] = source;
60517
60601
  const target = isArray(source) ? [] : {};
60518
60602
 
@@ -60528,15 +60612,18 @@ const toJSONObject = (obj) => {
60528
60612
  }
60529
60613
 
60530
60614
  return source;
60531
- }
60615
+ };
60532
60616
 
60533
60617
  return visit(obj, 0);
60534
- }
60618
+ };
60535
60619
 
60536
- const isAsyncFn = kindOfTest('AsyncFunction');
60620
+ const isAsyncFn = kindOfTest("AsyncFunction");
60537
60621
 
60538
60622
  const isThenable = (thing) =>
60539
- thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
60623
+ thing &&
60624
+ (isObject(thing) || isFunction(thing)) &&
60625
+ isFunction(thing.then) &&
60626
+ isFunction(thing.catch);
60540
60627
 
60541
60628
  // original code
60542
60629
  // https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
@@ -60546,32 +60633,35 @@ const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
60546
60633
  return setImmediate;
60547
60634
  }
60548
60635
 
60549
- return postMessageSupported ? ((token, callbacks) => {
60550
- _global.addEventListener("message", ({source, data}) => {
60551
- if (source === _global && data === token) {
60552
- callbacks.length && callbacks.shift()();
60553
- }
60554
- }, false);
60636
+ return postMessageSupported
60637
+ ? ((token, callbacks) => {
60638
+ _global.addEventListener(
60639
+ "message",
60640
+ ({ source, data }) => {
60641
+ if (source === _global && data === token) {
60642
+ callbacks.length && callbacks.shift()();
60643
+ }
60644
+ },
60645
+ false,
60646
+ );
60555
60647
 
60556
- return (cb) => {
60557
- callbacks.push(cb);
60558
- _global.postMessage(token, "*");
60559
- }
60560
- })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
60561
- })(
60562
- typeof setImmediate === 'function',
60563
- isFunction(_global.postMessage)
60564
- );
60648
+ return (cb) => {
60649
+ callbacks.push(cb);
60650
+ _global.postMessage(token, "*");
60651
+ };
60652
+ })(`axios@${Math.random()}`, [])
60653
+ : (cb) => setTimeout(cb);
60654
+ })(typeof setImmediate === "function", isFunction(_global.postMessage));
60565
60655
 
60566
- const asap = typeof queueMicrotask !== 'undefined' ?
60567
- queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);
60656
+ const asap =
60657
+ typeof queueMicrotask !== "undefined"
60658
+ ? queueMicrotask.bind(_global)
60659
+ : (typeof process !== "undefined" && process.nextTick) || _setImmediate;
60568
60660
 
60569
60661
  // *********************
60570
60662
 
60571
-
60572
60663
  const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
60573
60664
 
60574
-
60575
60665
  /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
60576
60666
  isArray,
60577
60667
  isArrayBuffer,
@@ -60629,7 +60719,7 @@ const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
60629
60719
  isThenable,
60630
60720
  setImmediate: _setImmediate,
60631
60721
  asap,
60632
- isIterable
60722
+ isIterable,
60633
60723
  });
60634
60724
 
60635
60725