@pactflow/openapi-pact-comparator 1.6.1 → 1.7.1

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] === '-';
@@ -3249,7 +3249,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	    const negativeNumberArg = (arg) => {
 	      // return false if not a negative number
-	      if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false;
+	      if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg)) return false;
 	      // negative number is ok unless digit used as an option in command hierarchy
 	      return !this._getCommandAndAncestors().some((cmd) =>
 	        cmd.options
@@ -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,13 +12204,13 @@ const minimumSchema = (originalSchema, oas) => {
         const subschema = cloneDeep(get$1(oas, path, {}));
         delete subschema.description;
         delete subschema.example;
-        traverse(schema, cleanupDiscriminators);
+        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) => {
@@ -15494,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 {
@@ -27268,6 +27592,7 @@ var Ajv$1 = /*@__PURE__*/getDefaultExportFromCjs(ajvExports);
 // a full schema can be found at https://github.com/pactflow/pact-schemas
 // but we don't use that here, because we try to be permissive with input
 const Interaction = Type.Object({
+    _skip: Type.Optional(Type.Boolean()),
     type: Type.Optional(Type.String()),
     description: Type.Optional(Type.String()),
     providerState: Type.Optional(Type.String()),
@@ -27396,9 +27721,9 @@ const parse = (pact) => {
     const interactionParser = version >= 4 ? interactionV4 : version >= 3 ? interactionV3 : interactionV1;
     return {
         metadata,
-        interactions: interactions
-            .filter(supportedInteractions)
-            .map(interactionParser),
+        interactions: interactions.map((i) => supportedInteractions(i)
+            ? interactionParser(i)
+            : { _skip: true }),
     };
 };
 class ParserError extends Error {
@@ -32180,6 +32505,10 @@ class Comparator {
         }
         const parsedPact = parse(pact);
         for (const [index, interaction] of parsedPact.interactions.entries()) {
+            if (interaction._skip) {
+                // non http/synchronous have been zero-ed out
+                continue;
+            }
             const { method, path, query } = interaction.request;
             let pathWithLeadingSlash = path.startsWith("/") ? path : `/${path}`;
             if (this.#config.get("no-percent-encoding")) {
@@ -32228,7 +32557,7 @@ class Comparator {
     }
 }
 
-var version = "1.6.1";
+var version = "1.7.1";
 var packageJson = {
 	version: version};