swagger-client 3.35.1 → 3.35.3

package/dist/swagger-client.browser.js

@@ -7117,21 +7117,18 @@ var ShortUniqueId = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  var index_exports = {};
+  __export(index_exports, {
     DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
     DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
     default: () => ShortUniqueId
   });
 
   // package.json
-  var version = "5.2.0";
+  var version = "5.3.2";
 
   // src/index.ts
   var DEFAULT_UUID_LENGTH = 6;
@@ -7204,10 +7201,11 @@ var ShortUniqueId = (() => {
       /* tslint:disable consistent-return */
       __publicField(this, "log", (...args) => {
         const finalArgs = [...args];
-        finalArgs[0] = `[short-unique-id] ${args[0]}`;
+        finalArgs[0] = "[short-unique-id] ".concat(args[0]);
         if (this.debug === true) {
           if (typeof console !== "undefined" && console !== null) {
-            return console.log(...finalArgs);
+            console.log(...finalArgs);
+            return;
           }
         }
       });
@@ -7218,23 +7216,43 @@ var ShortUniqueId = (() => {
           finalDict = dictionary;
         } else {
           finalDict = [];
-          let i;
-          this.dictIndex = i = 0;
-          const rangesName = `_${dictionary}_dict_ranges`;
+          this.dictIndex = 0;
+          const rangesName = "_".concat(dictionary, "_dict_ranges");
           const ranges = this._dict_ranges[rangesName];
-          Object.keys(ranges).forEach((rangeType) => {
-            const rangeTypeKey = rangeType;
-            this.dictRange = ranges[rangeTypeKey];
+          let capacity = 0;
+          for (const [, rangeValue] of Object.entries(ranges)) {
+            const [lower, upper] = rangeValue;
+            capacity += Math.abs(upper - lower);
+          }
+          finalDict = new Array(capacity);
+          let dictIdx = 0;
+          for (const [, rangeTypeValue] of Object.entries(ranges)) {
+            this.dictRange = rangeTypeValue;
             this.lowerBound = this.dictRange[0];
             this.upperBound = this.dictRange[1];
-            for (this.dictIndex = i = this.lowerBound; this.lowerBound <= this.upperBound ? i < this.upperBound : i > this.upperBound; this.dictIndex = this.lowerBound <= this.upperBound ? i += 1 : i -= 1) {
-              finalDict.push(String.fromCharCode(this.dictIndex));
+            const isAscending = this.lowerBound <= this.upperBound;
+            const start = this.lowerBound;
+            const end = this.upperBound;
+            if (isAscending) {
+              for (let i = start; i < end; i++) {
+                finalDict[dictIdx++] = String.fromCharCode(i);
+                this.dictIndex = i;
+              }
+            } else {
+              for (let i = start; i > end; i--) {
+                finalDict[dictIdx++] = String.fromCharCode(i);
+                this.dictIndex = i;
+              }
             }
-          });
+          }
+          finalDict.length = dictIdx;
         }
         if (shuffle) {
-          const PROBABILITY = 0.5;
-          finalDict = finalDict.sort(() => Math.random() - PROBABILITY);
+          const len = finalDict.length;
+          for (let i = len - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [finalDict[i], finalDict[j]] = [finalDict[j], finalDict[i]];
+          }
         }
         return finalDict;
       });
@@ -7252,15 +7270,16 @@ var ShortUniqueId = (() => {
        * @alias `const uid = new ShortUniqueId(); uid.seq();`
        */
       __publicField(this, "sequentialUUID", () => {
-        let counterDiv;
-        let counterRem;
-        let id = "";
-        counterDiv = this.counter;
+        const dictLen = this.dictLength;
+        const dict = this.dict;
+        let counterDiv = this.counter;
+        const idParts = [];
         do {
-          counterRem = counterDiv % this.dictLength;
-          counterDiv = Math.trunc(counterDiv / this.dictLength);
-          id += this.dict[counterRem];
+          const counterRem = counterDiv % dictLen;
+          counterDiv = Math.trunc(counterDiv / dictLen);
+          idParts.push(dict[counterRem]);
         } while (counterDiv !== 0);
+        const id = idParts.join("");
         this.counter += 1;
         return id;
       });
@@ -7272,22 +7291,17 @@ var ShortUniqueId = (() => {
        * @alias `const uid = new ShortUniqueId(); uid.rnd(uuidLength: number);`
        */
       __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
-        let id;
-        let randomPartIdx;
-        let j;
         if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
           throw new Error("Invalid UUID Length Provided");
         }
-        const isPositive = uuidLength >= 0;
-        id = "";
-        for (j = 0; j < uuidLength; j += 1) {
-          randomPartIdx = parseInt(
-            (Math.random() * this.dictLength).toFixed(0),
-            10
-          ) % this.dictLength;
-          id += this.dict[randomPartIdx];
+        const result = new Array(uuidLength);
+        const dictLen = this.dictLength;
+        const dict = this.dict;
+        for (let j = 0; j < uuidLength; j++) {
+          const randomPartIdx = Math.floor(Math.random() * dictLen);
+          result[j] = dict[randomPartIdx];
         }
-        return id;
+        return result.join("");
       });
       __publicField(this, "fmt", (format, date) => {
         return this.formattedUUID(format, date);
@@ -7298,24 +7312,21 @@ var ShortUniqueId = (() => {
        */
       __publicField(this, "formattedUUID", (format, date) => {
         const fnMap = {
-          "$r": this.randomUUID,
-          "$s": this.sequentialUUID,
-          "$t": this.stamp
+          $r: this.randomUUID,
+          $s: this.sequentialUUID,
+          $t: this.stamp
         };
-        const result = format.replace(
-          /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
-          (m) => {
-            const fn = m.slice(0, 2);
-            const len = parseInt(m.slice(2), 10);
-            if (fn === "$s") {
-              return fnMap[fn]().padStart(len, "0");
-            }
-            if (fn === "$t" && date) {
-              return fnMap[fn](len, date);
-            }
-            return fnMap[fn](len);
+        const result = format.replace(/\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g, (m) => {
+          const fn = m.slice(0, 2);
+          const len = Number.parseInt(m.slice(2), 10);
+          if (fn === "$s") {
+            return fnMap[fn]().padStart(len, "0");
           }
-        );
+          if (fn === "$t" && date) {
+            return fnMap[fn](len, date);
+          }
+          return fnMap[fn](len);
+        });
         return result;
       });
       /**
@@ -7336,9 +7347,7 @@ var ShortUniqueId = (() => {
        * This function returns `H`.
        */
       __publicField(this, "availableUUIDs", (uuidLength = this.uuidLength) => {
-        return parseFloat(
-          Math.pow([...new Set(this.dict)].length, uuidLength).toFixed(0)
-        );
+        return Number.parseFloat(([...new Set(this.dict)].length ** uuidLength).toFixed(0));
       });
       /**
        * Calculates approximate number of hashes before first collision.
@@ -7358,13 +7367,20 @@ var ShortUniqueId = (() => {
        * </div>
        *
        * This function returns `Q(H)`.
-       * 
+       *
        * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
        */
+      // Cache for memoization
+      __publicField(this, "_collisionCache", /* @__PURE__ */ new Map());
       __publicField(this, "approxMaxBeforeCollision", (rounds = this.availableUUIDs(this.uuidLength)) => {
-        return parseFloat(
-          Math.sqrt(Math.PI / 2 * rounds).toFixed(20)
-        );
+        const cacheKey = rounds;
+        const cached = this._collisionCache.get(cacheKey);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const result = Number.parseFloat(Math.sqrt(Math.PI / 2 * rounds).toFixed(20));
+        this._collisionCache.set(cacheKey, result);
+        return result;
       });
       /**
        * Calculates probability of generating duplicate UUIDs (a collision) in a
@@ -7385,14 +7401,14 @@ var ShortUniqueId = (() => {
        * </div>
        *
        * This function returns `p(r; H)`.
-       * 
+       *
        * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
        *
        * (Useful if you are wondering _"If I use this lib and expect to perform at most
        * `r` rounds of UUID generations, what is the probability that I will hit a duplicate UUID?"_.)
        */
       __publicField(this, "collisionProbability", (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
-        return parseFloat(
+        return Number.parseFloat(
           (this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20)
         );
       });
@@ -7419,7 +7435,7 @@ var ShortUniqueId = (() => {
        * and UUID length. The closer to 1, higher the uniqueness and thus better the quality.)
        */
       __publicField(this, "uniqueness", (rounds = this.availableUUIDs(this.uuidLength)) => {
-        const score = parseFloat(
+        const score = Number.parseFloat(
           (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
         );
         return score > 1 ? 1 : score < 0 ? 0 : score;
@@ -7432,12 +7448,12 @@ var ShortUniqueId = (() => {
       });
       /**
        * Generates a UUID with a timestamp that can be extracted using `uid.parseStamp(stampString);`.
-       * 
+       *
        * ```js
        *  const uidWithTimestamp = uid.stamp(32);
        *  console.log(uidWithTimestamp);
        *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
-       * 
+       *
        *  console.log(uid.parseStamp(uidWithTimestamp));
        *  // 2021-05-03T06:24:58.000Z
        *  ```
@@ -7458,16 +7474,16 @@ var ShortUniqueId = (() => {
         const idLength = finalLength - 9;
         const rndIdx = Math.round(Math.random() * (idLength > 15 ? 15 : idLength));
         const id = this.randomUUID(idLength);
-        return `${id.substring(0, rndIdx)}${hexStamp}${id.substring(rndIdx)}${rndIdx.toString(16)}`;
+        return "".concat(id.substring(0, rndIdx)).concat(hexStamp).concat(id.substring(rndIdx)).concat(rndIdx.toString(16));
       });
       /**
        * Extracts the date embeded in a UUID generated using the `uid.stamp(finalLength);` method.
-       * 
+       *
        * ```js
        *  const uidWithTimestamp = uid.stamp(32);
        *  console.log(uidWithTimestamp);
        *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
-       * 
+       *
        *  console.log(uid.parseStamp(uidWithTimestamp));
        *  // 2021-05-03T06:24:58.000Z
        *  ```
@@ -7476,32 +7492,26 @@ var ShortUniqueId = (() => {
         if (format && !/t0|t[1-9]\d{1,}/.test(format)) {
           throw new Error("Cannot extract date from a formated UUID with no timestamp in the format");
         }
-        const stamp = format ? format.replace(
-          /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
-          (m) => {
-            const fnMap = {
-              "$r": (len2) => [...Array(len2)].map(() => "r").join(""),
-              "$s": (len2) => [...Array(len2)].map(() => "s").join(""),
-              "$t": (len2) => [...Array(len2)].map(() => "t").join("")
-            };
-            const fn = m.slice(0, 2);
-            const len = parseInt(m.slice(2), 10);
-            return fnMap[fn](len);
-          }
-        ).replace(
-          /^(.*?)(t{8,})(.*)$/g,
-          (_m, p1, p2) => {
-            return suid.substring(p1.length, p1.length + p2.length);
-          }
-        ) : suid;
+        const stamp = format ? format.replace(/\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g, (m) => {
+          const fnMap = {
+            $r: (len2) => [...Array(len2)].map(() => "r").join(""),
+            $s: (len2) => [...Array(len2)].map(() => "s").join(""),
+            $t: (len2) => [...Array(len2)].map(() => "t").join("")
+          };
+          const fn = m.slice(0, 2);
+          const len = Number.parseInt(m.slice(2), 10);
+          return fnMap[fn](len);
+        }).replace(/^(.*?)(t{8,})(.*)$/g, (_m, p1, p2) => {
+          return suid.substring(p1.length, p1.length + p2.length);
+        }) : suid;
         if (stamp.length === 8) {
-          return new Date(parseInt(stamp, 16) * 1e3);
+          return new Date(Number.parseInt(stamp, 16) * 1e3);
         }
         if (stamp.length < 10) {
           throw new Error("Stamp length invalid");
         }
-        const rndIdx = parseInt(stamp.substring(stamp.length - 1), 16);
-        return new Date(parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
+        const rndIdx = Number.parseInt(stamp.substring(stamp.length - 1), 16);
+        return new Date(Number.parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
       });
       /**
        * Set the counter to a specific value.
@@ -7521,19 +7531,14 @@ var ShortUniqueId = (() => {
       this.debug = false;
       this.dict = [];
       this.version = version;
-      const {
-        dictionary,
-        shuffle,
-        length,
-        counter
-      } = options;
+      const { dictionary, shuffle, length, counter } = options;
       this.uuidLength = length;
       this.setDictionary(dictionary, shuffle);
       this.setCounter(counter);
       this.debug = options.debug;
       this.log(this.dict);
       this.log(
-        `Generator instantiated with Dictionary Size ${this.dictLength} and counter set to ${this.counter}`
+        "Generator instantiated with Dictionary Size ".concat(this.dictLength, " and counter set to ").concat(this.counter)
       );
       this.log = this.log.bind(this);
       this.setDictionary = this.setDictionary.bind(this);
@@ -7551,13 +7556,12 @@ var ShortUniqueId = (() => {
       this.getVersion = this.getVersion.bind(this);
       this.stamp = this.stamp.bind(this);
       this.parseStamp = this.parseStamp.bind(this);
-      return this;
     }
   };
   /** @hidden */
   __publicField(_ShortUniqueId, "default", _ShortUniqueId);
   var ShortUniqueId = _ShortUniqueId;
-  return __toCommonJS(src_exports);
+  return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=short-unique-id.js.map
  true&&(module.exports=ShortUniqueId.default),'undefined'!=typeof window&&(ShortUniqueId=ShortUniqueId.default);
@@ -10657,8 +10661,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (/* binding */ normalize)
 /* harmony export */ });
+/* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(24955);
 /* harmony import */ var _helpers_op_id_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(37896);
 
+
 function normalize(parsedSpec) {
   const {
     spec
@@ -10733,12 +10739,16 @@ function normalize(parsedSpec) {
           for (const inherits of inheritsList) {
             // eslint-disable-next-line no-restricted-syntax
             for (const inheritName in inherits) {
-              if (!operation[inheritName]) {
+              if (!Array.isArray(operation[inheritName])) {
                 operation[inheritName] = inherits[inheritName];
               } else if (inheritName === 'parameters') {
                 // eslint-disable-next-line no-restricted-syntax
                 for (const param of inherits[inheritName]) {
-                  const exists = operation[inheritName].some(opParam => opParam.name && opParam.name === param.name || opParam.$ref && opParam.$ref === param.$ref || opParam.$$ref && opParam.$$ref === param.$$ref || opParam === param);
+                  const exists = operation[inheritName].some(opParam => {
+                    if (!(0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__["default"])(opParam) && !(0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__["default"])(param)) return false;
+                    if (opParam === param) return true;
+                    return ['name', '$ref', '$$ref'].some(key => typeof opParam[key] === 'string' && typeof param[key] === 'string' && opParam[key] === param[key]);
+                  });
                   if (!exists) {
                     operation[inheritName].push(param);
                   }
@@ -27531,7 +27541,7 @@ const resolveSchema$idField = (retrievalURI, schemaElement) => {
   const ancestorsSchemaIdentifiers = (0,_swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__["default"])(schemaElement.meta.get('ancestorsSchemaIdentifiers'));
   return (0,ramda__WEBPACK_IMPORTED_MODULE_2__["default"])((acc, $id) => {
     return _util_url_mjs__WEBPACK_IMPORTED_MODULE_0__.resolve(acc, _util_url_mjs__WEBPACK_IMPORTED_MODULE_0__.sanitize(_util_url_mjs__WEBPACK_IMPORTED_MODULE_0__.stripHash($id)));
-  }, retrievalURI, [...ancestorsSchemaIdentifiers, (0,_swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__["default"])(schemaElement.$id)]);
+  }, retrievalURI, ancestorsSchemaIdentifiers);
 };
 
 /**