@pactflow/openapi-pact-comparator 2.1.0 → 2.3.0

package/dist/index.mjs

@@ -3912,8 +3912,23 @@ const splitPath = (path) => {
     }
     return path;
 };
-const dereferenceOas = (schema, oas) => (schema.$ref ? get$1(oas, splitPath(schema.$ref)) : schema);
-const dereferenceDoc = (schema, doc) => schema.$ref ? get$1(doc, splitPath(schema.$ref)) : schema;
+const followRefChain = (schema, doc, seen = new Set()) => {
+    if (!schema.$ref)
+        return { value: schema, ref: undefined };
+    if (seen.has(schema.$ref))
+        return { value: undefined, ref: undefined };
+    const resolved = get$1(doc, splitPath(schema.$ref));
+    if (resolved !== null && typeof resolved === "object" && "$ref" in resolved) {
+        const next = followRefChain(resolved, doc, new Set([...seen, schema.$ref]));
+        return next.value !== undefined
+            ? { value: next.value, ref: next.ref ?? schema.$ref }
+            : next;
+    }
+    return { value: resolved, ref: schema.$ref };
+};
+const dereferenceOas = (schema, oas) => (followRefChain(schema, oas).value ?? schema);
+const dereferenceDoc = (schema, doc) => followRefChain(schema, doc).value;
+const lastRefInChain = (schema, doc) => followRefChain(schema, doc).ref;
 const traverse = (schema, visitor) => {
     if (typeof schema === "boolean" || schema === undefined) {
         return;
@@ -3997,7 +4012,8 @@ function* iterateMessageList(messages, inlinePathBase, cache, doc) {
             const message = dereferenceDoc(ref, doc);
             if (!message)
                 continue;
-            const path = "[root]." + ref.$ref.replace(/^#\//, "").replace(/\//g, ".");
+            const finalRef = lastRefInChain(ref, doc) ?? ref.$ref;
+            const path = "[root]." + finalRef.replace(/^#\//, "").replace(/\//g, ".");
             const result = { message, path };
             cache.set(ref.$ref, result);
             yield result;
@@ -4250,14 +4266,199 @@ function* compareMessageHeaders(ajv, message, content, interactionContext, metad
     }
 }
 
-const canValidate$2 = (contentType) => {
+const PARAMETER_SEPARATOR = ";";
+const WILDCARD = "*";
+const TYPE_SUBTYPE_SEPARATOR = "/";
+const EXTENSION_SEPARATOR = "+";
+const quality = (a) => {
+    const match = /.*;q=([01].?\d*)/.exec(a);
+    return match ? parseFloat(match[1]) : 1.0;
+};
+const byQuality = (a, b) => {
+    return quality(b) - quality(a);
+};
+const ignoreCasing = (t) => t.toLowerCase();
+const ignoreWhitespace = (t) => t.replace(/\s+/g, "");
+const ignoreParameters = (t) => t.split(PARAMETER_SEPARATOR)[0];
+const removeQuality = (t) => t.replace(/;q=[01].?\d*/, "");
+const type$a = (t) => t.split(TYPE_SUBTYPE_SEPARATOR)[0];
+const subtype = (t) => {
+    const [_maintype, subtype] = t.split(TYPE_SUBTYPE_SEPARATOR);
+    return subtype?.split(EXTENSION_SEPARATOR).pop();
+};
+function findMatchingType(requestType, responseTypes) {
+    // exact match
+    let accept = requestType
+        .split(",")
+        .map(ignoreWhitespace)
+        .map(ignoreCasing)
+        .sort(byQuality)
+        .map(removeQuality);
+    let available = responseTypes.map(ignoreWhitespace).map(ignoreCasing);
+    for (const a of accept) {
+        const matchExactly = (t) => t === a;
+        const index = available.findIndex(matchExactly);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // ignore additional parameters
+    accept = accept.map(ignoreParameters);
+    available = available.map(ignoreParameters);
+    for (const a of accept) {
+        const matchExactly = (t) => t === a;
+        const index = available.findIndex(matchExactly);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // ignore vendor extensions
+    for (const a of accept) {
+        const matchTypesAndSubtypes = (t) => type$a(t) === type$a(a) && subtype(t) === subtype(a);
+        const index = available.findIndex(matchTypesAndSubtypes);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // wildcards in responseTypes
+    for (const a of accept) {
+        const matchSubtype = (t) => subtype(t) === WILDCARD && type$a(t) === type$a(a);
+        const index = available.findIndex(matchSubtype);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    if (available.includes(`${WILDCARD}/${WILDCARD}`)) {
+        return `${WILDCARD}/${WILDCARD}`;
+    }
+    // wildcards in requestTypes
+    for (const a of accept) {
+        const matchSubtype = (t) => subtype(a) === WILDCARD && type$a(t) === type$a(a);
+        const index = available.findIndex(matchSubtype);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    if (accept.includes(`${WILDCARD}/${WILDCARD}`)) {
+        return responseTypes[0];
+    }
+    return undefined;
+}
+const getByContentType = (object = {}, contentType) => {
+    const key = findMatchingType(contentType, Object.keys(object));
+    return object[key];
+};
+const standardHttpRequestHeaders = [
+    "accept",
+    "accept-charset",
+    "accept-datetime",
+    "accept-encoding",
+    "accept-language",
+    "authorization",
+    "cache-control",
+    "connection",
+    "content-length",
+    "content-md5",
+    "content-type",
+    "cookie",
+    "date",
+    "expect",
+    "forwarded",
+    "from",
+    "host",
+    "if-match",
+    "if-modified-since",
+    "if-none-match",
+    "if-range",
+    "if-unmodified-since",
+    "max-forwards",
+    "origin",
+    "pragma",
+    "proxy-authorization",
+    "range",
+    "referer",
+    "te",
+    "upgrade",
+    "user-agent",
+    "via",
+    "warning",
+];
+const standardHttpResponseHeaders = [
+    "access-control-allow-origin",
+    "accept-patch",
+    "accept-ranges",
+    "age",
+    "allow",
+    "alt-svc",
+    "cache-control",
+    "connection",
+    "content-disposition",
+    "content-encoding",
+    "content-language",
+    "content-length",
+    "content-location",
+    "content-md5",
+    "content-range",
+    "date",
+    "etag",
+    "expires",
+    "last-modified",
+    "link",
+    "location",
+    "p3p",
+    "pragma",
+    "proxy-authenticate",
+    "public-key-pins",
+    "refresh",
+    "retry-after",
+    "server",
+    "set-cookie",
+    "status",
+    "strict-transport-security",
+    "trailer",
+    "transfer-encoding",
+    "tsv",
+    "upgrade",
+    "vary",
+    "via",
+    "warning",
+    "www-authenticate",
+    "x-frame-options",
+];
+
+const VALIDATABLE_CONTENT_TYPES = [
+    "application/json",
+    "application/x-www-form-urlencoded",
+    "multipart/form-data",
+];
+const bodyValidationStatus = (contentType, body, validatableTypes = [...VALIDATABLE_CONTENT_TYPES]) => {
     if (typeof contentType !== "string")
-        return false;
-    const normalized = contentType.split(";", 1)[0].trim().toLowerCase();
-    return normalized === "application/json" || normalized.endsWith("+json");
+        return "skip";
+    if (findMatchingType(contentType, validatableTypes))
+        return "validate";
+    return body !== undefined ? "warn" : "skip";
 };
+
 function* compareMessagePayload(ajv, message, content, interactionContext, contentLocation, messagePath, direction) {
-    if (!canValidate$2(content.contentType))
+    const status = bodyValidationStatus(content.contentType, content.payload);
+    if (status === "warn") {
+        yield {
+            code: "message.payload.unvalidatable",
+            message: `Body with content type '${content.contentType}' is not supported by the spec comparator`,
+            mockDetails: {
+                ...baseMockDetails(interactionContext),
+                location: contentLocation,
+                value: content.payload,
+            },
+            specDetails: {
+                location: messagePath,
+                value: undefined,
+            },
+            type: "warning",
+        };
+        return;
+    }
+    if (status === "skip")
         return;
     if (!message.payload) {
         if (content.payload !== undefined) {
@@ -4325,12 +4526,13 @@ function checkAsyncapiPreamble(asyncapi, interaction, index, interactionKind) {
             },
         };
     }
+    const interactionKindTitleCase = `${interactionKind.charAt(0).toUpperCase()}${interactionKind.slice(1)}`;
     if (!interaction.asyncapiReferences) {
         return {
             ok: false,
             result: {
                 code: "message.references.missing",
-                message: `${interactionKind.charAt(0).toUpperCase()}${interactionKind.slice(1)} interaction has no AsyncAPI references in comments.references.AsyncAPI`,
+                message: `${interactionKindTitleCase} interaction has no AsyncAPI references in comments.references.AsyncAPI`,
                 mockDetails: {
                     ...baseMockDetails(interaction),
                     location: `[root].interactions[${index}].comments.references.AsyncAPI`,
@@ -4342,6 +4544,22 @@ function checkAsyncapiPreamble(asyncapi, interaction, index, interactionKind) {
         };
     }
     const { operationId } = interaction.asyncapiReferences;
+    if (!operationId) {
+        return {
+            ok: false,
+            result: {
+                code: "message.references.missing",
+                message: `${interactionKindTitleCase} interaction has a malformed AsyncAPI reference in comments.references.AsyncAPI: expected an "operationId" property`,
+                mockDetails: {
+                    ...baseMockDetails(interaction),
+                    location: `[root].interactions[${index}].comments.references.AsyncAPI`,
+                    value: interaction.asyncapiReferences,
+                },
+                specDetails: { location: "[root]", value: undefined },
+                type: "error",
+            },
+        };
+    }
     if (!asyncapi.operations?.[operationId]) {
         return {
             ok: false,
@@ -4720,16 +4938,16 @@ function requireMultipart () {
 var multipartExports = requireMultipart();
 var multipart = /*@__PURE__*/getDefaultExportFromCjs(multipartExports);
 
-var type$a;
+var type$9;
 var hasRequiredType;
 
 function requireType () {
-	if (hasRequiredType) return type$a;
+	if (hasRequiredType) return type$9;
 	hasRequiredType = 1;
 
 	/** @type {import('./type')} */
-	type$a = TypeError;
-	return type$a;
+	type$9 = TypeError;
+	return type$9;
 }
 
 var util_inspect;
@@ -6638,7 +6856,10 @@ function requireSideChannel () {
 		var channel = {
 			assert: function (key) {
 				if (!channel.has(key)) {
-					throw new $TypeError('Side channel does not contain ' + inspect(key));
+					var keyDesc = key && Object(key) === key
+						? 'the given object key'
+						: inspect(key);
+					throw new $TypeError('Side channel does not contain ' + keyDesc);
 				}
 			},
 			'delete': function (key) {
@@ -6658,7 +6879,7 @@ function requireSideChannel () {
 				$channelData.set(key, value);
 			}
 		};
-		// @ts-expect-error TODO: figure out why this is erroring
+
 		return channel;
 	};
 	return sideChannel;
@@ -6704,6 +6925,7 @@ function requireUtils$1 () {
 
 	var formats = /*@__PURE__*/ requireFormats$1();
 	var getSideChannel = requireSideChannel();
+	var defineProperty = /*@__PURE__*/ requireEsDefineProperty();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
@@ -6768,6 +6990,19 @@ function requireUtils$1 () {
 	    return obj;
 	};
 
+	var setProperty = function setProperty(obj, key, value) {
+	    if (key === '__proto__' && defineProperty) {
+	        defineProperty(obj, key, {
+	            configurable: true,
+	            enumerable: true,
+	            value: value,
+	            writable: true
+	        });
+	    } else {
+	        obj[key] = value;
+	    }
+	};
+
 	var merge = function merge(target, source, options) {
 	    /* eslint no-param-reassign: 0 */
 	    if (!source) {
@@ -6777,7 +7012,10 @@ function requireUtils$1 () {
 	    if (typeof source !== 'object' && typeof source !== 'function') {
 	        if (isArray(target)) {
 	            var nextIndex = target.length;
-	            if (options && typeof options.arrayLimit === 'number' && nextIndex > options.arrayLimit) {
+	            if (options && typeof options.arrayLimit === 'number' && nextIndex >= options.arrayLimit) {
+	                if (options.throwOnLimitExceeded) {
+	                    throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	                }
 	                return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
 	            }
 	            target[nextIndex] = source;
@@ -6817,6 +7055,9 @@ function requireUtils$1 () {
 	        }
 	        var combined = [target].concat(source);
 	        if (options && typeof options.arrayLimit === 'number' && combined.length > options.arrayLimit) {
+	            if (options.throwOnLimitExceeded) {
+	                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	            }
 	            return markOverflow(arrayToObject(combined, options), combined.length - 1);
 	        }
 	        return combined;
@@ -6840,6 +7081,12 @@ function requireUtils$1 () {
 	                target[i] = item;
 	            }
 	        });
+	        if (options && typeof options.arrayLimit === 'number' && target.length > options.arrayLimit) {
+	            if (options.throwOnLimitExceeded) {
+	                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	            }
+	            return markOverflow(arrayToObject(target, options), target.length - 1);
+	        }
 	        return target;
 	    }
 
@@ -6847,9 +7094,9 @@ function requireUtils$1 () {
 	        var value = source[key];
 
 	        if (has.call(acc, key)) {
-	            acc[key] = merge(acc[key], value, options);
+	            setProperty(acc, key, merge(acc[key], value, options));
 	        } else {
-	            acc[key] = value;
+	            setProperty(acc, key, value);
 	        }
 
 	        if (isOverflow(source) && !isOverflow(acc)) {
@@ -6868,7 +7115,7 @@ function requireUtils$1 () {
 
 	var assign = function assignSingleSource(target, source) {
 	    return Object.keys(source).reduce(function (acc, key) {
-	        acc[key] = source[key];
+	        setProperty(acc, key, source[key]);
 	        return acc;
 	    }, target);
 	};
@@ -6914,6 +7161,13 @@ function requireUtils$1 () {
 	    var out = '';
 	    for (var j = 0; j < string.length; j += limit) {
 	        var segment = string.length >= limit ? string.slice(j, j + limit) : string;
+	        if (j + limit < string.length) {
+	            var last = segment.charCodeAt(segment.length - 1);
+	            if (last >= 0xD800 && last <= 0xDBFF) {
+	                segment = segment.slice(0, -1);
+	                j -= 1;
+	            }
+	        }
 	        var arr = [];
 
 	        for (var i = 0; i < segment.length; ++i) {
@@ -6967,7 +7221,7 @@ function requireUtils$1 () {
 
 	var compact = function compact(value) {
 	    var queue = [{ obj: { o: value }, prop: 'o' }];
-	    var refs = [];
+	    var refs = getSideChannel();
 
 	    for (var i = 0; i < queue.length; ++i) {
 	        var item = queue[i];
@@ -6977,9 +7231,9 @@ function requireUtils$1 () {
 	        for (var j = 0; j < keys.length; ++j) {
 	            var key = keys[j];
 	            var val = obj[key];
-	            if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+	            if (typeof val === 'object' && val !== null && !refs.has(val)) {
 	                queue[queue.length] = { obj: obj, prop: key };
-	                refs[refs.length] = val;
+	                refs.set(val, true);
 	            }
 	        }
 	    }
@@ -7001,9 +7255,12 @@ function requireUtils$1 () {
 	    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
 	};
 
-	var combine = function combine(a, b, arrayLimit, plainObjects) {
+	var combine = function combine(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
 	    // If 'a' is already an overflow object, add to it
 	    if (isOverflow(a)) {
+	        if (throwOnLimitExceeded) {
+	            throw new RangeError('Array limit exceeded. Only ' + arrayLimit + ' element' + (arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	        }
 	        var newIndex = getMaxIndex(a) + 1;
 	        a[newIndex] = b;
 	        setMaxIndex(a, newIndex);
@@ -7012,6 +7269,9 @@ function requireUtils$1 () {
 
 	    var result = [].concat(a, b);
 	    if (result.length > arrayLimit) {
+	        if (throwOnLimitExceeded) {
+	            throw new RangeError('Array limit exceeded. Only ' + arrayLimit + ' element' + (arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	        }
 	        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
 	    }
 	    return result;
@@ -7459,8 +7719,19 @@ function requireParse$1 () {
 	    });
 	};
 
-	var parseArrayValue = function (val, options, currentArrayLength) {
+	var parseArrayValue = function (val, options, currentArrayLength, isFlatArrayValue) {
 	    if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
+	        if (isFlatArrayValue && options.throwOnLimitExceeded) {
+	            var commaCount = 0;
+	            var commaIndex = val.indexOf(',');
+	            while (commaIndex > -1) {
+	                commaCount += 1;
+	                if (commaCount >= options.arrayLimit) {
+	                    throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+	                }
+	                commaIndex = val.indexOf(',', commaIndex + 1);
+	            }
+	        }
 	        return val.split(',');
 	    }
 
@@ -7537,7 +7808,8 @@ function requireParse$1 () {
 	                    parseArrayValue(
 	                        part.slice(pos + 1),
 	                        options,
-	                        isArray(obj[key]) ? obj[key].length : 0
+	                        isArray(obj[key]) ? obj[key].length : 0,
+	                        part.indexOf('[]=') === -1
 	                    ),
 	                    function (encodedVal) {
 	                        return options.decoder(encodedVal, defaults.decoder, charset, 'value');
@@ -7555,10 +7827,7 @@ function requireParse$1 () {
 	        }
 
 	        if (options.comma && isArray(val) && val.length > options.arrayLimit) {
-	            if (options.throwOnLimitExceeded) {
-	                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
-	            }
-	            val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+	            val = utils.combine([], val, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
 	        }
 
 	        if (key !== null) {
@@ -7568,7 +7837,8 @@ function requireParse$1 () {
 	                    obj[key],
 	                    val,
 	                    options.arrayLimit,
-	                    options.plainObjects
+	                    options.plainObjects,
+	                    options.throwOnLimitExceeded
 	                );
 	            } else if (!existing || options.duplicates === 'last') {
 	                obj[key] = val;
@@ -7603,7 +7873,8 @@ function requireParse$1 () {
 	                        [],
 	                        leaf,
 	                        options.arrayLimit,
-	                        options.plainObjects
+	                        options.plainObjects,
+	                        options.throwOnLimitExceeded
 	                    );
 	            }
 	        } else {
@@ -7851,166 +8122,6 @@ var qs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
 const isValidRequest = (interaction) => interaction.response.status < 400;
 
-const PARAMETER_SEPARATOR = ";";
-const WILDCARD = "*";
-const TYPE_SUBTYPE_SEPARATOR = "/";
-const EXTENSION_SEPARATOR = "+";
-const quality = (a) => {
-    const match = /.*;q=([01].?\d*)/.exec(a);
-    return match ? parseFloat(match[1]) : 1.0;
-};
-const byQuality = (a, b) => {
-    return quality(b) - quality(a);
-};
-const ignoreCasing = (t) => t.toLowerCase();
-const ignoreWhitespace = (t) => t.replace(/\s+/g, "");
-const ignoreParameters = (t) => t.split(PARAMETER_SEPARATOR)[0];
-const removeQuality = (t) => t.replace(/;q=[01].?\d*/, "");
-const type$9 = (t) => t.split(TYPE_SUBTYPE_SEPARATOR)[0];
-const subtype = (t) => {
-    const [_maintype, subtype] = t.split(TYPE_SUBTYPE_SEPARATOR);
-    return subtype?.split(EXTENSION_SEPARATOR).pop();
-};
-function findMatchingType(requestType, responseTypes) {
-    // exact match
-    let accept = requestType
-        .split(",")
-        .map(ignoreWhitespace)
-        .map(ignoreCasing)
-        .sort(byQuality)
-        .map(removeQuality);
-    let available = responseTypes.map(ignoreWhitespace).map(ignoreCasing);
-    for (const a of accept) {
-        const matchExactly = (t) => t === a;
-        const index = available.findIndex(matchExactly);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // ignore additional parameters
-    accept = accept.map(ignoreParameters);
-    available = available.map(ignoreParameters);
-    for (const a of accept) {
-        const matchExactly = (t) => t === a;
-        const index = available.findIndex(matchExactly);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // ignore vendor extensions
-    for (const a of accept) {
-        const matchTypesAndSubtypes = (t) => type$9(t) === type$9(a) && subtype(t) === subtype(a);
-        const index = available.findIndex(matchTypesAndSubtypes);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // wildcards in responseTypes
-    for (const a of accept) {
-        const matchSubtype = (t) => subtype(t) === WILDCARD && type$9(t) === type$9(a);
-        const index = available.findIndex(matchSubtype);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    if (available.includes(`${WILDCARD}/${WILDCARD}`)) {
-        return `${WILDCARD}/${WILDCARD}`;
-    }
-    // wildcards in requestTypes
-    for (const a of accept) {
-        const matchSubtype = (t) => subtype(a) === WILDCARD && type$9(t) === type$9(a);
-        const index = available.findIndex(matchSubtype);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    if (accept.includes(`${WILDCARD}/${WILDCARD}`)) {
-        return responseTypes[0];
-    }
-    return undefined;
-}
-const getByContentType = (object = {}, contentType) => {
-    const key = findMatchingType(contentType, Object.keys(object));
-    return object[key];
-};
-const standardHttpRequestHeaders = [
-    "accept",
-    "accept-charset",
-    "accept-datetime",
-    "accept-encoding",
-    "accept-language",
-    "authorization",
-    "cache-control",
-    "connection",
-    "content-length",
-    "content-md5",
-    "content-type",
-    "cookie",
-    "date",
-    "expect",
-    "forwarded",
-    "from",
-    "host",
-    "if-match",
-    "if-modified-since",
-    "if-none-match",
-    "if-range",
-    "if-unmodified-since",
-    "max-forwards",
-    "origin",
-    "pragma",
-    "proxy-authorization",
-    "range",
-    "referer",
-    "te",
-    "upgrade",
-    "user-agent",
-    "via",
-    "warning",
-];
-const standardHttpResponseHeaders = [
-    "access-control-allow-origin",
-    "accept-patch",
-    "accept-ranges",
-    "age",
-    "allow",
-    "alt-svc",
-    "cache-control",
-    "connection",
-    "content-disposition",
-    "content-encoding",
-    "content-language",
-    "content-length",
-    "content-location",
-    "content-md5",
-    "content-range",
-    "date",
-    "etag",
-    "expires",
-    "last-modified",
-    "link",
-    "location",
-    "p3p",
-    "pragma",
-    "proxy-authenticate",
-    "public-key-pins",
-    "refresh",
-    "retry-after",
-    "server",
-    "set-cookie",
-    "status",
-    "strict-transport-security",
-    "trailer",
-    "transfer-encoding",
-    "tsv",
-    "upgrade",
-    "vary",
-    "via",
-    "warning",
-    "www-authenticate",
-    "x-frame-options",
-];
-
 const parseBody = (body, contentType, legacyParser) => {
     if (contentType.includes("application/x-www-form-urlencoded") &&
         typeof body === "string") {
@@ -8034,13 +8145,6 @@ const parseBody = (body, contentType, legacyParser) => {
     }
     return body;
 };
-const canValidate$1 = (contentType, disableMultipartFormdata) => {
-    return !!findMatchingType(contentType, [
-        "application/json",
-        "application/x-www-form-urlencoded",
-        disableMultipartFormdata ? "" : "multipart/form-data",
-    ].filter(Boolean));
-};
 const DEFAULT_CONTENT_TYPE$1 = "application/json";
 function* compareReqBody(ajv, route, interaction, index, config) {
     const { method, oas, operation, path } = route.store;
@@ -8060,8 +8164,30 @@ function* compareReqBody(ajv, route, interaction, index, config) {
     if (!required && body === undefined) {
         return;
     }
+    const bodyStatus = bodyValidationStatus(contentType, body, VALIDATABLE_CONTENT_TYPES.filter((t) => t !== "multipart/form-data" ||
+        !config.get("disable-multipart-formdata")));
+    if (bodyStatus === "skip")
+        return;
+    if (bodyStatus === "warn" && isValidRequest(interaction)) {
+        yield {
+            code: "request.body.unvalidatable",
+            message: `Body with content type '${contentType}' is not supported by the spec comparator`,
+            mockDetails: {
+                ...baseMockDetails(interaction),
+                location: `[root].interactions[${index}].request.body`,
+                value: body,
+            },
+            specDetails: {
+                location: `[root].paths.${path}.${method}.requestBody.content`,
+                pathMethod: method,
+                pathName: path,
+                value: get$1(operation, "requestBody.content"),
+            },
+            type: "warning",
+        };
+        return;
+    }
     if (schema &&
-        canValidate$1(contentType, config.get("disable-multipart-formdata")) &&
         isValidRequest(interaction) &&
         (config.get("no-validate-request-body-unless-application-json")
             ? !!findMatchingType("application/json", availableRequestContentTypes)
@@ -8153,7 +8279,8 @@ function* compareReqHeader(ajv, route, interaction, index, config) {
         Object.entries(operation.responses).reduce((acc, [_status, response]) => {
             return [
                 ...acc,
-                ...Object.keys(dereferenceOas(response || {}, oas)?.content || {}),
+                ...Object.keys(dereferenceOas(response || {}, oas)
+                    ?.content || {}),
             ];
         }, []);
     const availableResponseContentType = operation.produces ||
@@ -8700,9 +8827,6 @@ function* compareReqSecurity(ajv, route, interaction, index, config) {
 
 const patternedStatus = (status) => `${Math.floor(status / 100)}XX`;
 
-const canValidate = (contentType = "") => {
-    return !!findMatchingType(contentType, ["application/json"]);
-};
 const DEFAULT_CONTENT_TYPE = "application/json";
 function* compareResBody(ajv, route, interaction, index, config) {
     const { method, oas, operation, path } = route.store;
@@ -8757,14 +8881,15 @@ function* compareResBody(ajv, route, interaction, index, config) {
                 type: "warning",
             };
         }
-        if (value && canValidate(contentType) && !schema) {
+        const bodyStatus = bodyValidationStatus(contentType, value);
+        if (bodyStatus === "warn") {
             yield {
-                code: "response.body.unknown",
-                message: "No matching schema found for response body",
+                code: "response.body.unvalidatable",
+                message: `Body with content type '${contentType}' is not supported by the spec comparator`,
                 mockDetails: {
                     ...baseMockDetails(interaction),
                     location: `[root].interactions[${index}].response.body`,
-                    value: value,
+                    value,
                 },
                 specDetails: {
                     location: `[root].paths.${path}.${method}.responses.${status}.content`,
@@ -8772,32 +8897,52 @@ function* compareResBody(ajv, route, interaction, index, config) {
                     pathName: path,
                     value: response.content,
                 },
-                type: "error",
+                type: "warning",
             };
         }
-        if (value && canValidate(contentType) && schema) {
-            const schemaId = `[root].paths.${path}.${method}.responses.${status}.content.${contentType}`;
-            const validate = getValidateFunction(ajv, schemaId, () => transformReceivedSchema(minimumSchema(schema, oas), config.get("no-transform-non-nullable-response-schema")));
-            if (!validate(value)) {
-                for (const error of validate.errors) {
-                    yield {
-                        code: "response.body.incompatible",
-                        message: `Response body is incompatible with the response body schema in the spec file: ${formatMessage(error)}`,
-                        mockDetails: {
-                            ...baseMockDetails(interaction),
-                            location: `[root].interactions[${index}].response.body${formatInstancePath(error)}`,
-                            value: error.instancePath
-                                ? get$1(value, splitPath(error.instancePath))
-                                : value,
-                        },
-                        specDetails: {
-                            location: `${schemaId}.schema.${formatSchemaPath(error)}`,
-                            pathMethod: method,
-                            pathName: path,
-                            value: get$1(validate.schema, splitPath(error.schemaPath)),
-                        },
-                        type: "error",
-                    };
+        else if (bodyStatus === "validate") {
+            if (value && !schema) {
+                yield {
+                    code: "response.body.unknown",
+                    message: "No matching schema found for response body",
+                    mockDetails: {
+                        ...baseMockDetails(interaction),
+                        location: `[root].interactions[${index}].response.body`,
+                        value: value,
+                    },
+                    specDetails: {
+                        location: `[root].paths.${path}.${method}.responses.${status}.content`,
+                        pathMethod: method,
+                        pathName: path,
+                        value: response.content,
+                    },
+                    type: "error",
+                };
+            }
+            if (value && schema) {
+                const schemaId = `[root].paths.${path}.${method}.responses.${status}.content.${contentType}`;
+                const validate = getValidateFunction(ajv, schemaId, () => transformReceivedSchema(minimumSchema(schema, oas), config.get("no-transform-non-nullable-response-schema")));
+                if (!validate(value)) {
+                    for (const error of validate.errors) {
+                        yield {
+                            code: "response.body.incompatible",
+                            message: `Response body is incompatible with the response body schema in the spec file: ${formatMessage(error)}`,
+                            mockDetails: {
+                                ...baseMockDetails(interaction),
+                                location: `[root].interactions[${index}].response.body${formatInstancePath(error)}`,
+                                value: error.instancePath
+                                    ? get$1(value, splitPath(error.instancePath))
+                                    : value,
+                            },
+                            specDetails: {
+                                location: `${schemaId}.schema.${formatSchemaPath(error)}`,
+                                pathMethod: method,
+                                pathName: path,
+                                value: get$1(validate.schema, splitPath(error.schemaPath)),
+                            },
+                            type: "error",
+                        };
+                    }
                 }
             }
         }
@@ -8993,11 +9138,17 @@ function* compareHttpInteraction(ajvCoerce, ajvNocoerce, router, interaction, in
         return;
     }
     yield* compareReqSecurity(ajvCoerce, route, interaction, index, config);
-    yield* compareReqHeader(ajvCoerce, route, interaction, index, config);
+    const reqHeaderResults = Array.from(compareReqHeader(ajvCoerce, route, interaction, index, config));
+    yield* reqHeaderResults;
     yield* compareReqQuery(ajvCoerce, route, interaction, index, config);
-    yield* compareReqBody(ajvNocoerce, route, interaction, index, config);
-    yield* compareResHeader(ajvCoerce, route, interaction, index);
-    yield* compareResBody(ajvNocoerce, route, interaction, index, config);
+    if (!reqHeaderResults.some((r) => r.code === "request.content-type.incompatible")) {
+        yield* compareReqBody(ajvNocoerce, route, interaction, index, config);
+    }
+    const resHeaderResults = Array.from(compareResHeader(ajvCoerce, route, interaction, index));
+    yield* resHeaderResults;
+    if (!resHeaderResults.some((r) => r.code === "response.content-type.incompatible")) {
+        yield* compareResBody(ajvNocoerce, route, interaction, index, config);
+    }
 }
 
 const isSwagger2 = (oas) => Object.hasOwn(oas, "swagger") &&
@@ -17188,7 +17339,7 @@ function requireFastUri () {
 	      if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) {
 	        // convert Unicode IDN -> ASCII IDN
 	        try {
-	          parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+	          parsed.host = new URL('http://' + parsed.host).hostname;
 	        } catch (e) {
 	          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
 	        }
@@ -20348,9 +20499,7 @@ const AsyncMessage = Type.Object({
     metadata: Type.Optional(Type.Record(Type.String(), Type.String())),
     comments: Type.Optional(Type.Object({
         references: Type.Optional(Type.Object({
-            AsyncAPI: Type.Optional(Type.Object({
-                operationId: Type.String(),
-            })),
+            AsyncAPI: Type.Optional(Type.Unknown()),
         })),
     })),
 });
@@ -20370,9 +20519,7 @@ const SyncMessage = Type.Object({
     response: Type.Array(SyncMessageSide),
     comments: Type.Optional(Type.Object({
         references: Type.Optional(Type.Object({
-            AsyncAPI: Type.Optional(Type.Object({
-                operationId: Type.String(),
-            })),
+            AsyncAPI: Type.Optional(Type.Unknown()),
         })),
     })),
 });
@@ -20462,29 +20609,32 @@ const interactionV4 = (i) => ({
         headers: flattenValues(i.response?.headers),
     },
 });
+const asAsyncapiReferences = (asyncapiRef) => {
+    if (!asyncapiRef)
+        return undefined;
+    if (typeof asyncapiRef !== "object")
+        return {};
+    return { ...asyncapiRef };
+};
 const parseAsyncInteraction = (i) => {
-    const asyncapiRef = i.comments?.references?.AsyncAPI;
+    const asyncapiRef = asAsyncapiReferences(i.comments?.references?.AsyncAPI);
     return {
         _kind: "async",
         description: i.description,
         providerState: i.providerState,
-        asyncapiReferences: asyncapiRef
-            ? { operationId: asyncapiRef.operationId }
-            : undefined,
+        asyncapiReferences: asyncapiRef,
         payload: parseAsPactV4Body(i.contents),
         contentType: i.contents?.contentType,
         metadata: i.metadata,
     };
 };
 const parseSyncInteraction = (i) => {
-    const asyncapiRef = i.comments?.references?.AsyncAPI;
+    const asyncapiRef = asAsyncapiReferences(i.comments?.references?.AsyncAPI);
     return {
         _kind: "sync",
         description: i.description,
         providerState: i.providerState,
-        asyncapiReferences: asyncapiRef
-            ? { operationId: asyncapiRef.operationId }
-            : undefined,
+        asyncapiReferences: asyncapiRef,
         request: {
             payload: parseAsPactV4Body(i.request.contents),
             contentType: i.request.contents?.contentType,