@pactflow/openapi-pact-comparator 1.6.0 → 1.7.0

package/dist/cli.cjs

@@ -110,7 +110,7 @@ function requireArgument () {
 	        break;
 	    }
 
-	    if (this._name.length > 3 && this._name.slice(-3) === '...') {
+	    if (this._name.endsWith('...')) {
 	      this.variadic = true;
 	      this._name = this._name.slice(0, -3);
 	    }
@@ -130,12 +130,13 @@ function requireArgument () {
 	   * @package
 	   */
 
-	  _concatValue(value, previous) {
+	  _collectValue(value, previous) {
 	    if (previous === this.defaultValue || !Array.isArray(previous)) {
 	      return [value];
 	    }
 
-	    return previous.concat(value);
+	    previous.push(value);
+	    return previous;
 	  }
 
 	  /**
@@ -180,7 +181,7 @@ function requireArgument () {
 	        );
 	      }
 	      if (this.variadic) {
-	        return this._concatValue(arg, previous);
+	        return this._collectValue(arg, previous);
 	      }
 	      return arg;
 	    };
@@ -1157,12 +1158,13 @@ function requireOption () {
 	   * @package
 	   */
 
-	  _concatValue(value, previous) {
+	  _collectValue(value, previous) {
 	    if (previous === this.defaultValue || !Array.isArray(previous)) {
 	      return [value];
 	    }
 
-	    return previous.concat(value);
+	    previous.push(value);
+	    return previous;
 	  }
 
 	  /**
@@ -1181,7 +1183,7 @@ function requireOption () {
 	        );
 	      }
 	      if (this.variadic) {
-	        return this._concatValue(arg, previous);
+	        return this._collectValue(arg, previous);
 	      }
 	      return arg;
 	    };
@@ -1738,11 +1740,10 @@ function requireCommand () {
 	  configureOutput(configuration) {
 	    if (configuration === undefined) return this._outputConfiguration;
 
-	    this._outputConfiguration = Object.assign(
-	      {},
-	      this._outputConfiguration,
-	      configuration,
-	    );
+	    this._outputConfiguration = {
+	      ...this._outputConfiguration,
+	      ...configuration,
+	    };
 	    return this;
 	  }
 
@@ -1868,7 +1869,7 @@ function requireCommand () {
 	   */
 	  addArgument(argument) {
 	    const previousArgument = this.registeredArguments.slice(-1)[0];
-	    if (previousArgument && previousArgument.variadic) {
+	    if (previousArgument?.variadic) {
 	      throw new Error(
 	        `only the last argument can be variadic '${previousArgument.name()}'`,
 	      );
@@ -2193,7 +2194,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      if (val !== null && option.parseArg) {
 	        val = this._callParseArg(option, val, oldValue, invalidValueMessage);
 	      } else if (val !== null && option.variadic) {
-	        val = option._concatValue(val, oldValue);
+	        val = option._collectValue(val, oldValue);
 	      }
 
 	      // Fill-in appropriate missing values. Long winded but easy to follow.
@@ -2972,7 +2973,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	  _chainOrCall(promise, fn) {
 	    // thenable
-	    if (promise && promise.then && typeof promise.then === 'function') {
+	    if (promise?.then && typeof promise.then === 'function') {
 	      // already have a promise, chain callback
 	      return promise.then(() => fn());
 	    }
@@ -3103,7 +3104,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      promiseChain = this._chainOrCallHooks(promiseChain, 'postAction');
 	      return promiseChain;
 	    }
-	    if (this.parent && this.parent.listenerCount(commandEvent)) {
+	    if (this.parent?.listenerCount(commandEvent)) {
 	      checkForUnknownOptions();
 	      this._processArguments();
 	      this.parent.emit(commandEvent, operands, unknown); // legacy
@@ -3233,15 +3234,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   *     sub --unknown uuu op => [sub], [--unknown uuu op]
 	   *     sub -- --unknown uuu op => [sub --unknown uuu op], []
 	   *
-	   * @param {string[]} argv
+	   * @param {string[]} args
 	   * @return {{operands: string[], unknown: string[]}}
 	   */
 
-	  parseOptions(argv) {
+	  parseOptions(args) {
 	    const operands = []; // operands, not options or values
 	    const unknown = []; // first unknown option and remaining unknown args
 	    let dest = operands;
-	    const args = argv.slice();
 
 	    function maybeOption(arg) {
 	      return arg.length > 1 && arg[0] === '-';
@@ -3260,13 +3260,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	    // parse options
 	    let activeVariadicOption = null;
-	    while (args.length) {
-	      const arg = args.shift();
+	    let activeGroup = null; // working through group of short options, like -abc
+	    let i = 0;
+	    while (i < args.length || activeGroup) {
+	      const arg = activeGroup ?? args[i++];
+	      activeGroup = null;
 
 	      // literal
 	      if (arg === '--') {
 	        if (dest === unknown) dest.push(arg);
-	        dest.push(...args);
+	        dest.push(...args.slice(i));
 	        break;
 	      }
 
@@ -3284,17 +3287,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        // recognised option, call listener to assign value with possible custom processing
 	        if (option) {
 	          if (option.required) {
-	            const value = args.shift();
+	            const value = args[i++];
 	            if (value === undefined) this.optionMissingArgument(option);
 	            this.emit(`option:${option.name()}`, value);
 	          } else if (option.optional) {
 	            let value = null;
 	            // historical behaviour is optional value is following arg unless an option
 	            if (
-	              args.length > 0 &&
-	              (!maybeOption(args[0]) || negativeNumberArg(args[0]))
+	              i < args.length &&
+	              (!maybeOption(args[i]) || negativeNumberArg(args[i]))
 	            ) {
-	              value = args.shift();
+	              value = args[i++];
 	            }
 	            this.emit(`option:${option.name()}`, value);
 	          } else {
@@ -3317,9 +3320,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	            // option with value following in same argument
 	            this.emit(`option:${option.name()}`, arg.slice(2));
 	          } else {
-	            // boolean option, emit and put back remainder of arg for further processing
+	            // boolean option
 	            this.emit(`option:${option.name()}`);
-	            args.unshift(`-${arg.slice(2)}`);
+	            // remove the processed option and keep processing group
+	            activeGroup = `-${arg.slice(2)}`;
 	          }
 	          continue;
 	        }
@@ -3356,26 +3360,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      ) {
 	        if (this._findCommand(arg)) {
 	          operands.push(arg);
-	          if (args.length > 0) unknown.push(...args);
+	          unknown.push(...args.slice(i));
 	          break;
 	        } else if (
 	          this._getHelpCommand() &&
 	          arg === this._getHelpCommand().name()
 	        ) {
-	          operands.push(arg);
-	          if (args.length > 0) operands.push(...args);
+	          operands.push(arg, ...args.slice(i));
 	          break;
 	        } else if (this._defaultCommandName) {
-	          unknown.push(arg);
-	          if (args.length > 0) unknown.push(...args);
+	          unknown.push(arg, ...args.slice(i));
 	          break;
 	        }
 	      }
 
 	      // If using passThroughOptions, stop processing options at first command-argument.
 	      if (this._passThroughOptions) {
-	        dest.push(arg);
-	        if (args.length > 0) dest.push(...args);
+	        dest.push(arg, ...args.slice(i));
 	        break;
 	      }
 
@@ -5152,7 +5153,7 @@ function resolveYamlMerge(data) {
   return data === '<<' || data === null;
 }
 
-var merge = new type$b('tag:yaml.org,2002:merge', {
+var merge$1 = new type$b('tag:yaml.org,2002:merge', {
   kind: 'scalar',
   resolve: resolveYamlMerge
 });
@@ -5401,7 +5402,7 @@ var set$1 = new type$b('tag:yaml.org,2002:set', {
 var _default = core$2.extend({
   implicit: [
     timestamp,
-    merge
+    merge$1
   ],
   explicit: [
     binary,
@@ -8140,7 +8141,7 @@ var types$3 = {
   timestamp: timestamp,
   bool:      bool,
   int:       int,
-  merge:     merge,
+  merge:     merge$1,
   omap:      omap,
   seq:       seq,
   str:       str
@@ -9047,6 +9048,18 @@ function overRest(func, start, transform) {
   };
 }
 
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + '');
+}
+
 /** Used as references for various `Number` constants. */
 var MAX_SAFE_INTEGER = 9007199254740991;
 
@@ -9110,6 +9123,63 @@ function isArrayLike(value) {
   return value != null && isLength(value.length) && !isFunction(value);
 }
 
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ *  else `false`.
+ */
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == 'number'
+        ? (isArrayLike(object) && isIndex(index, object.length))
+        : (type == 'string' && index in object)
+      ) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index = -1,
+        length = sources.length,
+        customizer = length > 1 ? sources[length - 1] : undefined,
+        guard = length > 2 ? sources[2] : undefined;
+
+    customizer = (assigner.length > 3 && typeof customizer == 'function')
+      ? (length--, customizer)
+      : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+
 /** Used for built-in method references. */
 var objectProto$9 = Object.prototype;
 
@@ -11341,6 +11411,209 @@ function createBaseEach(eachFunc, fromRight) {
  */
 var baseEach = createBaseEach(baseForOwn);
 
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+  if ((value !== undefined && !eq(object[key], value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+function isArrayLikeObject(value) {
+  return isObjectLike(value) && isArrayLike(value);
+}
+
+/**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function safeGet(object, key) {
+  if (key === 'constructor' && typeof object[key] === 'function') {
+    return;
+  }
+
+  if (key == '__proto__') {
+    return;
+  }
+
+  return object[key];
+}
+
+/**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */
+function toPlainObject(value) {
+  return copyObject(value, keysIn(value));
+}
+
+/**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet(object, key),
+      srcValue = safeGet(source, key),
+      stacked = stack.get(srcValue);
+
+  if (stacked) {
+    assignMergeValue(object, key, stacked);
+    return;
+  }
+  var newValue = customizer
+    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+    : undefined;
+
+  var isCommon = newValue === undefined;
+
+  if (isCommon) {
+    var isArr = isArray(srcValue),
+        isBuff = !isArr && isBuffer(srcValue),
+        isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray(objValue)) {
+        newValue = objValue;
+      }
+      else if (isArrayLikeObject(objValue)) {
+        newValue = copyArray(objValue);
+      }
+      else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer(srcValue, true);
+      }
+      else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue, true);
+      }
+      else {
+        newValue = [];
+      }
+    }
+    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+      newValue = objValue;
+      if (isArguments(objValue)) {
+        newValue = toPlainObject(objValue);
+      }
+      else if (!isObject(objValue) || isFunction(objValue)) {
+        newValue = initCloneObject(srcValue);
+      }
+    }
+    else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    // Recursively merge objects and arrays (susceptible to call stack limits).
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack['delete'](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+
+/**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack);
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    }
+    else {
+      var newValue = customizer
+        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+        : undefined;
+
+      if (newValue === undefined) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+
 /**
  * This function is like `arrayIncludes` except that it accepts a comparator.
  *
@@ -11439,6 +11712,41 @@ function parent(object, path) {
   return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
 }
 
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ *   'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ *   'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+var merge = createAssigner(function(object, source, srcIndex) {
+  baseMerge(object, source, srcIndex);
+});
+
 /**
  * The base implementation of `_.unset`.
  *
@@ -11755,22 +12063,6 @@ const traverseWithDereferencing = (schema, visitor) => {
     _traverseWithDereferencing(schema, schema, [], visitor);
 };
 
-const transformRequestSchema = (schema) => {
-    // OpenAPI defines allOf to mean the union of all sub-schemas. JSON-Schema
-    // defines allOf to mean that *every* sub-schema needs to be satisfied. In
-    // draft 2019-09, JSON-Schema added "unevaluatedProperties" to support this
-    // behaviour
-    traverseWithDereferencing(schema, (s) => {
-        if (s.allOf) {
-            forEach(s.allOf, (ss) => {
-                delete ss.additionalProperties;
-            });
-            s.unevaluatedProperties = false;
-        }
-    });
-    return schema;
-};
-
 const transformResponseSchema = (schema, noTransformNonNullableResponseSchema) => {
     // a provider must provide a superset of what the consumer asks for
     // additionalProperties expected in pact response are disallowed
@@ -11794,30 +12086,62 @@ const transformResponseSchema = (schema, noTransformNonNullableResponseSchema) =
         }
         delete s.required;
     });
-    // OpenAPI defines allOf to mean the union of all sub-schemas. JSON-Schema
-    // defines allOf to mean that *every* sub-schema needs to be satisfied. In
-    // draft 2019-09, JSON-Schema added "unevaluatedProperties" to support this
-    // behaviour
-    traverseWithDereferencing(schema, (s) => {
-        if (s.allOf) {
-            forEach(s.allOf, (ss) => {
-                let subschema = ss;
-                if (subschema.$ref) {
-                    subschema = get$1(schema, splitPath(subschema.$ref));
-                }
-                delete subschema.additionalProperties;
-                if (subschema.allOf) {
-                    // traversal is depth-first; if nested allOf, remove
-                    // unevaluatedProperties from previously set deeper schema
-                    delete subschema.unevaluatedProperties;
-                }
-            });
-            s.unevaluatedProperties = false;
-        }
-    });
     return schema;
 };
 
+function _flat(s, root) {
+    if (s.allOf) {
+        const { allOf, ...others } = s;
+        return merge(others, ...allOf.map((ss) => {
+            let dereferenced;
+            if (ss.$ref) {
+                const { $ref, ...others } = ss;
+                dereferenced = {
+                    ...others,
+                    ...get$1(root, splitPath($ref)),
+                };
+            }
+            return _flat(dereferenced || ss, root);
+        }));
+    }
+    if (s.properties) {
+        for (const ss in s.properties) {
+            s.properties[ss] = _flat(s.properties[ss], root);
+        }
+        return s;
+    }
+    for (const key of [
+        "oneOf",
+        "anyOf",
+        "not",
+        "items",
+        "additionalProperties",
+    ]) {
+        if (s[key]) {
+            return {
+                ...s,
+                [key]: Array.isArray(s[key])
+                    ? s[key].map((ss) => _flat(ss, root))
+                    : _flat(s[key], root),
+            };
+        }
+    }
+    return s;
+}
+// OpenAPI defines allOf to mean the union of all sub-schemas. JSON-Schema
+// defines allOf to mean that *every* sub-schema needs to be satisfied.
+// To handle the difference, we flatten 'allOf'
+function flattenAllOf(s, refs) {
+    // main schema
+    const flattened = _flat(s, s);
+    // any other references
+    for (const ref of refs) {
+        const path = splitPath(ref);
+        set(flattened, path, _flat(get$1(s, path), s));
+    }
+    return flattened;
+}
+
 // draft-06 onwards converts exclusiveMinimum and exclusiveMaximum to numbers
 const convertExclusiveMinMax = (s) => {
     if (s.exclusiveMaximum === true) {
@@ -11880,12 +12204,13 @@ const minimumSchema = (originalSchema, oas) => {
         const subschema = cloneDeep(get$1(oas, path, {}));
         delete subschema.description;
         delete subschema.example;
+        traverse(subschema, cleanupDiscriminators);
         traverse(subschema, collectReferences);
         traverse(subschema, handleNullableSchema);
         traverse(subschema, convertExclusiveMinMax);
         set(schema, path, subschema);
     }
-    return schema;
+    return flattenAllOf(schema, refAdded);
 };
 
 const isSimpleSchema = (s, oas) => {
@@ -15493,7 +15818,7 @@ function* compareReqBody(ajv, route, interaction, index, config) {
             : true)) {
         const value = parseBody(body, requestContentType, config.get("legacy-parser"));
         const schemaId = `[root].paths.${path}.${method}.requestBody.content.${contentType}`;
-        const validate = getValidateFunction(ajv, schemaId, () => transformRequestSchema(minimumSchema(schema, oas)));
+        const validate = getValidateFunction(ajv, schemaId, () => minimumSchema(schema, oas));
         if (!validate(value)) {
             for (const error of validate.errors) {
                 yield {
@@ -23326,44 +23651,6 @@ var uri = {};
 
 var fastUri = {exports: {}};
 
-var scopedChars;
-var hasRequiredScopedChars;
-
-function requireScopedChars () {
-	if (hasRequiredScopedChars) return scopedChars;
-	hasRequiredScopedChars = 1;
-
-	const HEX = {
-	  0: 0,
-	  1: 1,
-	  2: 2,
-	  3: 3,
-	  4: 4,
-	  5: 5,
-	  6: 6,
-	  7: 7,
-	  8: 8,
-	  9: 9,
-	  a: 10,
-	  A: 10,
-	  b: 11,
-	  B: 11,
-	  c: 12,
-	  C: 12,
-	  d: 13,
-	  D: 13,
-	  e: 14,
-	  E: 14,
-	  f: 15,
-	  F: 15
-	};
-
-	scopedChars = {
-	  HEX
-	};
-	return scopedChars;
-}
-
 var utils;
 var hasRequiredUtils;
 
@@ -23371,62 +23658,100 @@ function requireUtils () {
 	if (hasRequiredUtils) return utils;
 	hasRequiredUtils = 1;
 
-	const { HEX } = requireScopedChars();
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
 
-	const IPV4_REG = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u;
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
 
-	function normalizeIPv4 (host) {
-	  if (findToken(host, '.') < 3) { return { host, isIPV4: false } }
-	  const matches = host.match(IPV4_REG) || [];
-	  const [address] = matches;
-	  if (address) {
-	    return { host: stripLeadingZeros(address, '.'), isIPV4: true }
-	  } else {
-	    return { host, isIPV4: false }
+	/**
+	 * @param {Array<string>} input
+	 * @returns {string}
+	 */
+	function stringArrayToHexStripped (input) {
+	  let acc = '';
+	  let code = 0;
+	  let i = 0;
+
+	  for (i = 0; i < input.length; i++) {
+	    code = input[i].charCodeAt(0);
+	    if (code === 48) {
+	      continue
+	    }
+	    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {
+	      return ''
+	    }
+	    acc += input[i];
+	    break
+	  }
+
+	  for (i += 1; i < input.length; i++) {
+	    code = input[i].charCodeAt(0);
+	    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {
+	      return ''
+	    }
+	    acc += input[i];
 	  }
+	  return acc
 	}
 
 	/**
-	 * @param {string[]} input
-	 * @param {boolean} [keepZero=false]
-	 * @returns {string|undefined}
+	 * @typedef {Object} GetIPV6Result
+	 * @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	 * @property {string} address - The parsed IPv6 address.
+	 * @property {string} [zone] - The zone identifier, if present.
 	 */
-	function stringArrayToHexStripped (input, keepZero = false) {
-	  let acc = '';
-	  let strip = true;
-	  for (const c of input) {
-	    if (HEX[c] === undefined) return undefined
-	    if (c !== '0' && strip === true) strip = false;
-	    if (!strip) acc += c;
+
+	/**
+	 * @param {string} value
+	 * @returns {boolean}
+	 */
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+
+	/**
+	 * @param {Array<string>} buffer
+	 * @returns {boolean}
+	 */
+	function consumeIsZone (buffer) {
+	  buffer.length = 0;
+	  return true
+	}
+
+	/**
+	 * @param {Array<string>} buffer
+	 * @param {Array<string>} address
+	 * @param {GetIPV6Result} output
+	 * @returns {boolean}
+	 */
+	function consumeHextets (buffer, address, output) {
+	  if (buffer.length) {
+	    const hex = stringArrayToHexStripped(buffer);
+	    if (hex !== '') {
+	      address.push(hex);
+	    } else {
+	      output.error = true;
+	      return false
+	    }
+	    buffer.length = 0;
 	  }
-	  if (keepZero && acc.length === 0) acc = '0';
-	  return acc
+	  return true
 	}
 
+	/**
+	 * @param {string} input
+	 * @returns {GetIPV6Result}
+	 */
 	function getIPV6 (input) {
 	  let tokenCount = 0;
 	  const output = { error: false, address: '', zone: '' };
+	  /** @type {Array<string>} */
 	  const address = [];
+	  /** @type {Array<string>} */
 	  const buffer = [];
-	  let isZone = false;
 	  let endipv6Encountered = false;
 	  let endIpv6 = false;
 
-	  function consume () {
-	    if (buffer.length) {
-	      if (isZone === false) {
-	        const hex = stringArrayToHexStripped(buffer);
-	        if (hex !== undefined) {
-	          address.push(hex);
-	        } else {
-	          output.error = true;
-	          return false
-	        }
-	      }
-	      buffer.length = 0;
-	    }
-	    return true
-	  }
+	  let consume = consumeHextets;
 
 	  for (let i = 0; i < input.length; i++) {
 	    const cursor = input[i];
@@ -23435,29 +23760,28 @@ function requireUtils () {
 	      if (endipv6Encountered === true) {
 	        endIpv6 = true;
 	      }
-	      if (!consume()) { break }
-	      tokenCount++;
-	      address.push(':');
-	      if (tokenCount > 7) {
+	      if (!consume(buffer, address, output)) { break }
+	      if (++tokenCount > 7) {
 	        // not valid
 	        output.error = true;
 	        break
 	      }
-	      if (i - 1 >= 0 && input[i - 1] === ':') {
+	      if (i > 0 && input[i - 1] === ':') {
 	        endipv6Encountered = true;
 	      }
+	      address.push(':');
 	      continue
 	    } else if (cursor === '%') {
-	      if (!consume()) { break }
+	      if (!consume(buffer, address, output)) { break }
 	      // switch to zone detection
-	      isZone = true;
+	      consume = consumeIsZone;
 	    } else {
 	      buffer.push(cursor);
 	      continue
 	    }
 	  }
 	  if (buffer.length) {
-	    if (isZone) {
+	    if (consume === consumeIsZone) {
 	      output.zone = buffer.join('');
 	    } else if (endIpv6) {
 	      address.push(buffer.join(''));
@@ -23469,6 +23793,17 @@ function requireUtils () {
 	  return output
 	}
 
+	/**
+	 * @typedef {Object} NormalizeIPv6Result
+	 * @property {string} host - The normalized host.
+	 * @property {string} [escapedHost] - The escaped host.
+	 * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	 */
+
+	/**
+	 * @param {string} host
+	 * @returns {NormalizeIPv6Result}
+	 */
 	function normalizeIPv6 (host) {
 	  if (findToken(host, ':') < 2) { return { host, isIPV6: false } }
 	  const ipv6 = getIPV6(host);
@@ -23480,35 +23815,17 @@ function requireUtils () {
 	      newHost += '%' + ipv6.zone;
 	      escapedHost += '%25' + ipv6.zone;
 	    }
-	    return { host: newHost, escapedHost, isIPV6: true }
+	    return { host: newHost, isIPV6: true, escapedHost }
 	  } else {
 	    return { host, isIPV6: false }
 	  }
 	}
 
-	function stripLeadingZeros (str, token) {
-	  let out = '';
-	  let skip = true;
-	  const l = str.length;
-	  for (let i = 0; i < l; i++) {
-	    const c = str[i];
-	    if (c === '0' && skip) {
-	      if ((i + 1 <= l && str[i + 1] === token) || i + 1 === l) {
-	        out += c;
-	        skip = false;
-	      }
-	    } else {
-	      if (c === token) {
-	        skip = true;
-	      } else {
-	        skip = false;
-	      }
-	      out += c;
-	    }
-	  }
-	  return out
-	}
-
+	/**
+	 * @param {string} str
+	 * @param {string} token
+	 * @returns {number}
+	 */
 	function findToken (str, token) {
 	  let ind = 0;
 	  for (let i = 0; i < str.length; i++) {
@@ -23517,98 +23834,160 @@ function requireUtils () {
 	  return ind
 	}
 
-	const RDS1 = /^\.\.?\//u;
-	const RDS2 = /^\/\.(?:\/|$)/u;
-	const RDS3 = /^\/\.\.(?:\/|$)/u;
-	const RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
-
-	function removeDotSegments (input) {
+	/**
+	 * @param {string} path
+	 * @returns {string}
+	 *
+	 * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	 */
+	function removeDotSegments (path) {
+	  let input = path;
 	  const output = [];
+	  let nextSlash = -1;
+	  let len = 0;
 
-	  while (input.length) {
-	    if (input.match(RDS1)) {
-	      input = input.replace(RDS1, '');
-	    } else if (input.match(RDS2)) {
-	      input = input.replace(RDS2, '/');
-	    } else if (input.match(RDS3)) {
-	      input = input.replace(RDS3, '/');
-	      output.pop();
-	    } else if (input === '.' || input === '..') {
-	      input = '';
-	    } else {
-	      const im = input.match(RDS5);
-	      if (im) {
-	        const s = im[0];
-	        input = input.slice(s.length);
-	        output.push(s);
+	  // eslint-disable-next-line no-cond-assign
+	  while (len = input.length) {
+	    if (len === 1) {
+	      if (input === '.') {
+	        break
+	      } else if (input === '/') {
+	        output.push('/');
+	        break
 	      } else {
-	        throw new Error('Unexpected dot segment condition')
+	        output.push(input);
+	        break
+	      }
+	    } else if (len === 2) {
+	      if (input[0] === '.') {
+	        if (input[1] === '.') {
+	          break
+	        } else if (input[1] === '/') {
+	          input = input.slice(2);
+	          continue
+	        }
+	      } else if (input[0] === '/') {
+	        if (input[1] === '.' || input[1] === '/') {
+	          output.push('/');
+	          break
+	        }
+	      }
+	    } else if (len === 3) {
+	      if (input === '/..') {
+	        if (output.length !== 0) {
+	          output.pop();
+	        }
+	        output.push('/');
+	        break
 	      }
 	    }
+	    if (input[0] === '.') {
+	      if (input[1] === '.') {
+	        if (input[2] === '/') {
+	          input = input.slice(3);
+	          continue
+	        }
+	      } else if (input[1] === '/') {
+	        input = input.slice(2);
+	        continue
+	      }
+	    } else if (input[0] === '/') {
+	      if (input[1] === '.') {
+	        if (input[2] === '/') {
+	          input = input.slice(2);
+	          continue
+	        } else if (input[2] === '.') {
+	          if (input[3] === '/') {
+	            input = input.slice(3);
+	            if (output.length !== 0) {
+	              output.pop();
+	            }
+	            continue
+	          }
+	        }
+	      }
+	    }
+
+	    // Rule 2E: Move normal path segment to output
+	    if ((nextSlash = input.indexOf('/', 1)) === -1) {
+	      output.push(input);
+	      break
+	    } else {
+	      output.push(input.slice(0, nextSlash));
+	      input = input.slice(nextSlash);
+	    }
 	  }
+
 	  return output.join('')
 	}
 
-	function normalizeComponentEncoding (components, esc) {
+	/**
+	 * @param {import('../types/index').URIComponent} component
+	 * @param {boolean} esc
+	 * @returns {import('../types/index').URIComponent}
+	 */
+	function normalizeComponentEncoding (component, esc) {
 	  const func = esc !== true ? escape : unescape;
-	  if (components.scheme !== undefined) {
-	    components.scheme = func(components.scheme);
+	  if (component.scheme !== undefined) {
+	    component.scheme = func(component.scheme);
 	  }
-	  if (components.userinfo !== undefined) {
-	    components.userinfo = func(components.userinfo);
+	  if (component.userinfo !== undefined) {
+	    component.userinfo = func(component.userinfo);
 	  }
-	  if (components.host !== undefined) {
-	    components.host = func(components.host);
+	  if (component.host !== undefined) {
+	    component.host = func(component.host);
 	  }
-	  if (components.path !== undefined) {
-	    components.path = func(components.path);
+	  if (component.path !== undefined) {
+	    component.path = func(component.path);
 	  }
-	  if (components.query !== undefined) {
-	    components.query = func(components.query);
+	  if (component.query !== undefined) {
+	    component.query = func(component.query);
 	  }
-	  if (components.fragment !== undefined) {
-	    components.fragment = func(components.fragment);
+	  if (component.fragment !== undefined) {
+	    component.fragment = func(component.fragment);
 	  }
-	  return components
+	  return component
 	}
 
-	function recomposeAuthority (components) {
+	/**
+	 * @param {import('../types/index').URIComponent} component
+	 * @returns {string|undefined}
+	 */
+	function recomposeAuthority (component) {
 	  const uriTokens = [];
 
-	  if (components.userinfo !== undefined) {
-	    uriTokens.push(components.userinfo);
+	  if (component.userinfo !== undefined) {
+	    uriTokens.push(component.userinfo);
 	    uriTokens.push('@');
 	  }
 
-	  if (components.host !== undefined) {
-	    let host = unescape(components.host);
-	    const ipV4res = normalizeIPv4(host);
-
-	    if (ipV4res.isIPV4) {
-	      host = ipV4res.host;
-	    } else {
-	      const ipV6res = normalizeIPv6(ipV4res.host);
+	  if (component.host !== undefined) {
+	    let host = unescape(component.host);
+	    if (!isIPv4(host)) {
+	      const ipV6res = normalizeIPv6(host);
 	      if (ipV6res.isIPV6 === true) {
 	        host = `[${ipV6res.escapedHost}]`;
 	      } else {
-	        host = components.host;
+	        host = component.host;
 	      }
 	    }
 	    uriTokens.push(host);
 	  }
 
-	  if (typeof components.port === 'number' || typeof components.port === 'string') {
+	  if (typeof component.port === 'number' || typeof component.port === 'string') {
 	    uriTokens.push(':');
-	    uriTokens.push(String(components.port));
+	    uriTokens.push(String(component.port));
 	  }
 
 	  return uriTokens.length ? uriTokens.join('') : undefined
 	}
 	utils = {
+	  nonSimpleDomain,
 	  recomposeAuthority,
 	  normalizeComponentEncoding,
 	  removeDotSegments,
-	  normalizeIPv4,
+	  isIPv4,
+	  isUUID,
 	  normalizeIPv6,
 	  stringArrayToHexStripped
 	};
@@ -23622,192 +24001,271 @@ function requireSchemes () {
 	if (hasRequiredSchemes) return schemes;
 	hasRequiredSchemes = 1;
 
-	const UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
+	const { isUUID } = requireUtils();
 	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
 
-	function isSecure (wsComponents) {
-	  return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === 'wss'
+	const supportedSchemeNames = /** @type {const} */ (['http', 'https', 'ws',
+	  'wss', 'urn', 'urn:uuid']);
+
+	/** @typedef {supportedSchemeNames[number]} SchemeName */
+
+	/**
+	 * @param {string} name
+	 * @returns {name is SchemeName}
+	 */
+	function isValidSchemeName (name) {
+	  return supportedSchemeNames.indexOf(/** @type {*} */ (name)) !== -1
 	}
 
-	function httpParse (components) {
-	  if (!components.host) {
-	    components.error = components.error || 'HTTP URIs must have a host.';
+	/**
+	 * @callback SchemeFn
+	 * @param {import('../types/index').URIComponent} component
+	 * @param {import('../types/index').Options} options
+	 * @returns {import('../types/index').URIComponent}
+	 */
+
+	/**
+	 * @typedef {Object} SchemeHandler
+	 * @property {SchemeName} scheme - The scheme name.
+	 * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
+	 * @property {SchemeFn} parse - Function to parse the URI component for this scheme.
+	 * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
+	 * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
+	 * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
+	 * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
+	 */
+
+	/**
+	 * @param {import('../types/index').URIComponent} wsComponent
+	 * @returns {boolean}
+	 */
+	function wsIsSecure (wsComponent) {
+	  if (wsComponent.secure === true) {
+	    return true
+	  } else if (wsComponent.secure === false) {
+	    return false
+	  } else if (wsComponent.scheme) {
+	    return (
+	      wsComponent.scheme.length === 3 &&
+	      (wsComponent.scheme[0] === 'w' || wsComponent.scheme[0] === 'W') &&
+	      (wsComponent.scheme[1] === 's' || wsComponent.scheme[1] === 'S') &&
+	      (wsComponent.scheme[2] === 's' || wsComponent.scheme[2] === 'S')
+	    )
+	  } else {
+	    return false
+	  }
+	}
+
+	/** @type {SchemeFn} */
+	function httpParse (component) {
+	  if (!component.host) {
+	    component.error = component.error || 'HTTP URIs must have a host.';
 	  }
 
-	  return components
+	  return component
 	}
 
-	function httpSerialize (components) {
-	  const secure = String(components.scheme).toLowerCase() === 'https';
+	/** @type {SchemeFn} */
+	function httpSerialize (component) {
+	  const secure = String(component.scheme).toLowerCase() === 'https';
 
 	  // normalize the default port
-	  if (components.port === (secure ? 443 : 80) || components.port === '') {
-	    components.port = undefined;
+	  if (component.port === (secure ? 443 : 80) || component.port === '') {
+	    component.port = undefined;
 	  }
 
 	  // normalize the empty path
-	  if (!components.path) {
-	    components.path = '/';
+	  if (!component.path) {
+	    component.path = '/';
 	  }
 
 	  // NOTE: We do not parse query strings for HTTP URIs
 	  // as WWW Form Url Encoded query strings are part of the HTML4+ spec,
 	  // and not the HTTP spec.
 
-	  return components
+	  return component
 	}
 
-	function wsParse (wsComponents) {
+	/** @type {SchemeFn} */
+	function wsParse (wsComponent) {
 	// indicate if the secure flag is set
-	  wsComponents.secure = isSecure(wsComponents);
+	  wsComponent.secure = wsIsSecure(wsComponent);
 
 	  // construct resouce name
-	  wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');
-	  wsComponents.path = undefined;
-	  wsComponents.query = undefined;
+	  wsComponent.resourceName = (wsComponent.path || '/') + (wsComponent.query ? '?' + wsComponent.query : '');
+	  wsComponent.path = undefined;
+	  wsComponent.query = undefined;
 
-	  return wsComponents
+	  return wsComponent
 	}
 
-	function wsSerialize (wsComponents) {
+	/** @type {SchemeFn} */
+	function wsSerialize (wsComponent) {
 	// normalize the default port
-	  if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === '') {
-	    wsComponents.port = undefined;
+	  if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === '') {
+	    wsComponent.port = undefined;
 	  }
 
 	  // ensure scheme matches secure flag
-	  if (typeof wsComponents.secure === 'boolean') {
-	    wsComponents.scheme = (wsComponents.secure ? 'wss' : 'ws');
-	    wsComponents.secure = undefined;
+	  if (typeof wsComponent.secure === 'boolean') {
+	    wsComponent.scheme = (wsComponent.secure ? 'wss' : 'ws');
+	    wsComponent.secure = undefined;
 	  }
 
 	  // reconstruct path from resource name
-	  if (wsComponents.resourceName) {
-	    const [path, query] = wsComponents.resourceName.split('?');
-	    wsComponents.path = (path && path !== '/' ? path : undefined);
-	    wsComponents.query = query;
-	    wsComponents.resourceName = undefined;
+	  if (wsComponent.resourceName) {
+	    const [path, query] = wsComponent.resourceName.split('?');
+	    wsComponent.path = (path && path !== '/' ? path : undefined);
+	    wsComponent.query = query;
+	    wsComponent.resourceName = undefined;
 	  }
 
 	  // forbid fragment component
-	  wsComponents.fragment = undefined;
+	  wsComponent.fragment = undefined;
 
-	  return wsComponents
+	  return wsComponent
 	}
 
-	function urnParse (urnComponents, options) {
-	  if (!urnComponents.path) {
-	    urnComponents.error = 'URN can not be parsed';
-	    return urnComponents
+	/** @type {SchemeFn} */
+	function urnParse (urnComponent, options) {
+	  if (!urnComponent.path) {
+	    urnComponent.error = 'URN can not be parsed';
+	    return urnComponent
 	  }
-	  const matches = urnComponents.path.match(URN_REG);
+	  const matches = urnComponent.path.match(URN_REG);
 	  if (matches) {
-	    const scheme = options.scheme || urnComponents.scheme || 'urn';
-	    urnComponents.nid = matches[1].toLowerCase();
-	    urnComponents.nss = matches[2];
-	    const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
-	    const schemeHandler = SCHEMES[urnScheme];
-	    urnComponents.path = undefined;
+	    const scheme = options.scheme || urnComponent.scheme || 'urn';
+	    urnComponent.nid = matches[1].toLowerCase();
+	    urnComponent.nss = matches[2];
+	    const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
+	    const schemeHandler = getSchemeHandler(urnScheme);
+	    urnComponent.path = undefined;
 
 	    if (schemeHandler) {
-	      urnComponents = schemeHandler.parse(urnComponents, options);
+	      urnComponent = schemeHandler.parse(urnComponent, options);
 	    }
 	  } else {
-	    urnComponents.error = urnComponents.error || 'URN can not be parsed.';
+	    urnComponent.error = urnComponent.error || 'URN can not be parsed.';
 	  }
 
-	  return urnComponents
+	  return urnComponent
 	}
 
-	function urnSerialize (urnComponents, options) {
-	  const scheme = options.scheme || urnComponents.scheme || 'urn';
-	  const nid = urnComponents.nid.toLowerCase();
+	/** @type {SchemeFn} */
+	function urnSerialize (urnComponent, options) {
+	  if (urnComponent.nid === undefined) {
+	    throw new Error('URN without nid cannot be serialized')
+	  }
+	  const scheme = options.scheme || urnComponent.scheme || 'urn';
+	  const nid = urnComponent.nid.toLowerCase();
 	  const urnScheme = `${scheme}:${options.nid || nid}`;
-	  const schemeHandler = SCHEMES[urnScheme];
+	  const schemeHandler = getSchemeHandler(urnScheme);
 
 	  if (schemeHandler) {
-	    urnComponents = schemeHandler.serialize(urnComponents, options);
+	    urnComponent = schemeHandler.serialize(urnComponent, options);
 	  }
 
-	  const uriComponents = urnComponents;
-	  const nss = urnComponents.nss;
-	  uriComponents.path = `${nid || options.nid}:${nss}`;
+	  const uriComponent = urnComponent;
+	  const nss = urnComponent.nss;
+	  uriComponent.path = `${nid || options.nid}:${nss}`;
 
 	  options.skipEscape = true;
-	  return uriComponents
+	  return uriComponent
 	}
 
-	function urnuuidParse (urnComponents, options) {
-	  const uuidComponents = urnComponents;
-	  uuidComponents.uuid = uuidComponents.nss;
-	  uuidComponents.nss = undefined;
+	/** @type {SchemeFn} */
+	function urnuuidParse (urnComponent, options) {
+	  const uuidComponent = urnComponent;
+	  uuidComponent.uuid = uuidComponent.nss;
+	  uuidComponent.nss = undefined;
 
-	  if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
-	    uuidComponents.error = uuidComponents.error || 'UUID is not valid.';
+	  if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
+	    uuidComponent.error = uuidComponent.error || 'UUID is not valid.';
 	  }
 
-	  return uuidComponents
+	  return uuidComponent
 	}
 
-	function urnuuidSerialize (uuidComponents) {
-	  const urnComponents = uuidComponents;
+	/** @type {SchemeFn} */
+	function urnuuidSerialize (uuidComponent) {
+	  const urnComponent = uuidComponent;
 	  // normalize UUID
-	  urnComponents.nss = (uuidComponents.uuid || '').toLowerCase();
-	  return urnComponents
+	  urnComponent.nss = (uuidComponent.uuid || '').toLowerCase();
+	  return urnComponent
 	}
 
-	const http = {
+	const http = /** @type {SchemeHandler} */ ({
 	  scheme: 'http',
 	  domainHost: true,
 	  parse: httpParse,
 	  serialize: httpSerialize
-	};
+	});
 
-	const https = {
+	const https = /** @type {SchemeHandler} */ ({
 	  scheme: 'https',
 	  domainHost: http.domainHost,
 	  parse: httpParse,
 	  serialize: httpSerialize
-	};
+	});
 
-	const ws = {
+	const ws = /** @type {SchemeHandler} */ ({
 	  scheme: 'ws',
 	  domainHost: true,
 	  parse: wsParse,
 	  serialize: wsSerialize
-	};
+	});
 
-	const wss = {
+	const wss = /** @type {SchemeHandler} */ ({
 	  scheme: 'wss',
 	  domainHost: ws.domainHost,
 	  parse: ws.parse,
 	  serialize: ws.serialize
-	};
+	});
 
-	const urn = {
+	const urn = /** @type {SchemeHandler} */ ({
 	  scheme: 'urn',
 	  parse: urnParse,
 	  serialize: urnSerialize,
 	  skipNormalize: true
-	};
+	});
 
-	const urnuuid = {
+	const urnuuid = /** @type {SchemeHandler} */ ({
 	  scheme: 'urn:uuid',
 	  parse: urnuuidParse,
 	  serialize: urnuuidSerialize,
 	  skipNormalize: true
-	};
+	});
 
-	const SCHEMES = {
+	const SCHEMES = /** @type {Record<SchemeName, SchemeHandler>} */ ({
 	  http,
 	  https,
 	  ws,
 	  wss,
 	  urn,
 	  'urn:uuid': urnuuid
-	};
+	});
 
-	schemes = SCHEMES;
+	Object.setPrototypeOf(SCHEMES, null);
+
+	/**
+	 * @param {string|undefined} scheme
+	 * @returns {SchemeHandler|undefined}
+	 */
+	function getSchemeHandler (scheme) {
+	  return (
+	    scheme && (
+	      SCHEMES[/** @type {SchemeName} */ (scheme)] ||
+	      SCHEMES[/** @type {SchemeName} */(scheme.toLowerCase())])
+	  ) ||
+	    undefined
+	}
+
+	schemes = {
+	  wsIsSecure,
+	  SCHEMES,
+	  isValidSchemeName,
+	  getSchemeHandler,
+	};
 	return schemes;
 }
 
@@ -23817,29 +24275,50 @@ function requireFastUri () {
 	if (hasRequiredFastUri) return fastUri.exports;
 	hasRequiredFastUri = 1;
 
-	const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = requireUtils();
-	const SCHEMES = requireSchemes();
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = requireUtils();
+	const { SCHEMES, getSchemeHandler } = requireSchemes();
 
+	/**
+	 * @template {import('./types/index').URIComponent|string} T
+	 * @param {T} uri
+	 * @param {import('./types/index').Options} [options]
+	 * @returns {T}
+	 */
 	function normalize (uri, options) {
 	  if (typeof uri === 'string') {
-	    uri = serialize(parse(uri, options), options);
+	    uri = /** @type {T} */ (serialize(parse(uri, options), options));
 	  } else if (typeof uri === 'object') {
-	    uri = parse(serialize(uri, options), options);
+	    uri = /** @type {T} */ (parse(serialize(uri, options), options));
 	  }
 	  return uri
 	}
 
+	/**
+	 * @param {string} baseURI
+	 * @param {string} relativeURI
+	 * @param {import('./types/index').Options} [options]
+	 * @returns {string}
+	 */
 	function resolve (baseURI, relativeURI, options) {
-	  const schemelessOptions = Object.assign({ scheme: 'null' }, options);
-	  const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
-	  return serialize(resolved, { ...schemelessOptions, skipEscape: true })
+	  const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' };
+	  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+	  schemelessOptions.skipEscape = true;
+	  return serialize(resolved, schemelessOptions)
 	}
 
-	function resolveComponents (base, relative, options, skipNormalization) {
+	/**
+	 * @param {import ('./types/index').URIComponent} base
+	 * @param {import ('./types/index').URIComponent} relative
+	 * @param {import('./types/index').Options} [options]
+	 * @param {boolean} [skipNormalization=false]
+	 * @returns {import ('./types/index').URIComponent}
+	 */
+	function resolveComponent (base, relative, options, skipNormalization) {
+	  /** @type {import('./types/index').URIComponent} */
 	  const target = {};
 	  if (!skipNormalization) {
-	    base = parse(serialize(base, options), options); // normalize base components
-	    relative = parse(serialize(relative, options), options); // normalize relative components
+	    base = parse(serialize(base, options), options); // normalize base component
+	    relative = parse(serialize(relative, options), options); // normalize relative component
 	  }
 	  options = options || {};
 
@@ -23868,7 +24347,7 @@ function requireFastUri () {
 	          target.query = base.query;
 	        }
 	      } else {
-	        if (relative.path.charAt(0) === '/') {
+	        if (relative.path[0] === '/') {
 	          target.path = removeDotSegments(relative.path);
 	        } else {
 	          if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
@@ -23895,6 +24374,12 @@ function requireFastUri () {
 	  return target
 	}
 
+	/**
+	 * @param {import ('./types/index').URIComponent|string} uriA
+	 * @param {import ('./types/index').URIComponent|string} uriB
+	 * @param {import ('./types/index').Options} options
+	 * @returns {boolean}
+	 */
 	function equal (uriA, uriB, options) {
 	  if (typeof uriA === 'string') {
 	    uriA = unescape(uriA);
@@ -23913,8 +24398,13 @@ function requireFastUri () {
 	  return uriA.toLowerCase() === uriB.toLowerCase()
 	}
 
+	/**
+	 * @param {Readonly<import('./types/index').URIComponent>} cmpts
+	 * @param {import('./types/index').Options} [opts]
+	 * @returns {string}
+	 */
 	function serialize (cmpts, opts) {
-	  const components = {
+	  const component = {
 	    host: cmpts.host,
 	    scheme: cmpts.scheme,
 	    userinfo: cmpts.userinfo,
@@ -23934,28 +24424,28 @@ function requireFastUri () {
 	  const uriTokens = [];
 
 	  // find scheme handler
-	  const schemeHandler = SCHEMES[(options.scheme || components.scheme || '').toLowerCase()];
+	  const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
 
 	  // perform scheme specific serialization
-	  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
+	  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
 
-	  if (components.path !== undefined) {
+	  if (component.path !== undefined) {
 	    if (!options.skipEscape) {
-	      components.path = escape(components.path);
+	      component.path = escape(component.path);
 
-	      if (components.scheme !== undefined) {
-	        components.path = components.path.split('%3A').join(':');
+	      if (component.scheme !== undefined) {
+	        component.path = component.path.split('%3A').join(':');
 	      }
 	    } else {
-	      components.path = unescape(components.path);
+	      component.path = unescape(component.path);
 	    }
 	  }
 
-	  if (options.reference !== 'suffix' && components.scheme) {
-	    uriTokens.push(components.scheme, ':');
+	  if (options.reference !== 'suffix' && component.scheme) {
+	    uriTokens.push(component.scheme, ':');
 	  }
 
-	  const authority = recomposeAuthority(components);
+	  const authority = recomposeAuthority(component);
 	  if (authority !== undefined) {
 	    if (options.reference !== 'suffix') {
 	      uriTokens.push('//');
@@ -23963,51 +24453,49 @@ function requireFastUri () {
 
 	    uriTokens.push(authority);
 
-	    if (components.path && components.path.charAt(0) !== '/') {
+	    if (component.path && component.path[0] !== '/') {
 	      uriTokens.push('/');
 	    }
 	  }
-	  if (components.path !== undefined) {
-	    let s = components.path;
+	  if (component.path !== undefined) {
+	    let s = component.path;
 
 	    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
 	      s = removeDotSegments(s);
 	    }
 
-	    if (authority === undefined) {
-	      s = s.replace(/^\/\//u, '/%2F'); // don't allow the path to start with "//"
+	    if (
+	      authority === undefined &&
+	      s[0] === '/' &&
+	      s[1] === '/'
+	    ) {
+	      // don't allow the path to start with "//"
+	      s = '/%2F' + s.slice(2);
 	    }
 
 	    uriTokens.push(s);
 	  }
 
-	  if (components.query !== undefined) {
-	    uriTokens.push('?', components.query);
+	  if (component.query !== undefined) {
+	    uriTokens.push('?', component.query);
 	  }
 
-	  if (components.fragment !== undefined) {
-	    uriTokens.push('#', components.fragment);
+	  if (component.fragment !== undefined) {
+	    uriTokens.push('#', component.fragment);
 	  }
 	  return uriTokens.join('')
 	}
 
-	const hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
-
-	function nonSimpleDomain (value) {
-	  let code = 0;
-	  for (let i = 0, len = value.length; i < len; ++i) {
-	    code = value.charCodeAt(i);
-	    if (code > 126 || hexLookUp[code]) {
-	      return true
-	    }
-	  }
-	  return false
-	}
-
 	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
 
+	/**
+	 * @param {string} uri
+	 * @param {import('./types/index').Options} [opts]
+	 * @returns
+	 */
 	function parse (uri, opts) {
 	  const options = Object.assign({}, opts);
+	  /** @type {import('./types/index').URIComponent} */
 	  const parsed = {
 	    scheme: undefined,
 	    userinfo: undefined,
@@ -24017,9 +24505,15 @@ function requireFastUri () {
 	    query: undefined,
 	    fragment: undefined
 	  };
-	  const gotEncoding = uri.indexOf('%') !== -1;
+
 	  let isIP = false;
-	  if (options.reference === 'suffix') uri = (options.scheme ? options.scheme + ':' : '') + '//' + uri;
+	  if (options.reference === 'suffix') {
+	    if (options.scheme) {
+	      uri = options.scheme + ':' + uri;
+	    } else {
+	      uri = '//' + uri;
+	    }
+	  }
 
 	  const matches = uri.match(URI_PARSE);
 
@@ -24038,13 +24532,12 @@ function requireFastUri () {
 	      parsed.port = matches[5];
 	    }
 	    if (parsed.host) {
-	      const ipv4result = normalizeIPv4(parsed.host);
-	      if (ipv4result.isIPV4 === false) {
-	        const ipv6result = normalizeIPv6(ipv4result.host);
+	      const ipv4result = isIPv4(parsed.host);
+	      if (ipv4result === false) {
+	        const ipv6result = normalizeIPv6(parsed.host);
 	        parsed.host = ipv6result.host.toLowerCase();
 	        isIP = ipv6result.isIPV6;
 	      } else {
-	        parsed.host = ipv4result.host;
 	        isIP = true;
 	      }
 	    }
@@ -24064,7 +24557,7 @@ function requireFastUri () {
 	    }
 
 	    // find scheme handler
-	    const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || '').toLowerCase()];
+	    const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
 
 	    // check if scheme can't handle IRIs
 	    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
@@ -24081,11 +24574,13 @@ function requireFastUri () {
 	    }
 
 	    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
-	      if (gotEncoding && parsed.scheme !== undefined) {
-	        parsed.scheme = unescape(parsed.scheme);
-	      }
-	      if (gotEncoding && parsed.host !== undefined) {
-	        parsed.host = unescape(parsed.host);
+	      if (uri.indexOf('%') !== -1) {
+	        if (parsed.scheme !== undefined) {
+	          parsed.scheme = unescape(parsed.scheme);
+	        }
+	        if (parsed.host !== undefined) {
+	          parsed.host = unescape(parsed.host);
+	        }
 	      }
 	      if (parsed.path) {
 	        parsed.path = escape(unescape(parsed.path));
@@ -24109,7 +24604,7 @@ function requireFastUri () {
 	  SCHEMES,
 	  normalize,
 	  resolve,
-	  resolveComponents,
+	  resolveComponent,
 	  equal,
 	  serialize,
 	  parse
@@ -32057,7 +32552,7 @@ class Comparator {
     }
 }
 
-var version = "1.6.0";
+var version = "1.7.0";
 var packageJson = {
 	version: version};