@pactflow/openapi-pact-comparator 1.11.0 → 1.12.0

package/dist/cli.cjs

@@ -4321,6 +4321,10 @@ const {
   Help,
 } = commander;
 
+var version = "1.12.0";
+var packageJson = {
+	version: version};
+
 /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
 function isNothing(subject) {
   return (typeof subject === 'undefined') || (subject === null);
@@ -8188,17 +8192,17 @@ var root = freeGlobal || freeSelf || Function('return this')();
 var Symbol$2 = root.Symbol;
 
 /** Used for built-in method references. */
-var objectProto$d = Object.prototype;
+var objectProto$e = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$a = objectProto$d.hasOwnProperty;
+var hasOwnProperty$b = objectProto$e.hasOwnProperty;
 
 /**
  * Used to resolve the
  * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  * of values.
  */
-var nativeObjectToString$1 = objectProto$d.toString;
+var nativeObjectToString$1 = objectProto$e.toString;
 
 /** Built-in value references. */
 var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
@@ -8211,7 +8215,7 @@ var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
  * @returns {string} Returns the raw `toStringTag`.
  */
 function getRawTag(value) {
-  var isOwn = hasOwnProperty$a.call(value, symToStringTag$1),
+  var isOwn = hasOwnProperty$b.call(value, symToStringTag$1),
       tag = value[symToStringTag$1];
 
   try {
@@ -8231,14 +8235,14 @@ function getRawTag(value) {
 }
 
 /** Used for built-in method references. */
-var objectProto$c = Object.prototype;
+var objectProto$d = Object.prototype;
 
 /**
  * Used to resolve the
  * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  * of values.
  */
-var nativeObjectToString = objectProto$c.toString;
+var nativeObjectToString = objectProto$d.toString;
 
 /**
  * Converts `value` to a string using `Object.prototype.toString`.
@@ -8539,17 +8543,17 @@ var reIsHostCtor = /^\[object .+?Constructor\]$/;
 
 /** Used for built-in method references. */
 var funcProto$1 = Function.prototype,
-    objectProto$b = Object.prototype;
+    objectProto$c = Object.prototype;
 
 /** Used to resolve the decompiled source of functions. */
 var funcToString$1 = funcProto$1.toString;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+var hasOwnProperty$a = objectProto$c.hasOwnProperty;
 
 /** Used to detect if a method is native. */
 var reIsNative = RegExp('^' +
-  funcToString$1.call(hasOwnProperty$9).replace(reRegExpChar, '\\$&')
+  funcToString$1.call(hasOwnProperty$a).replace(reRegExpChar, '\\$&')
   .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
 );
 
@@ -8964,10 +8968,10 @@ function eq(value, other) {
 }
 
 /** Used for built-in method references. */
-var objectProto$a = Object.prototype;
+var objectProto$b = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
 
 /**
  * Assigns `value` to `key` of `object` if the existing value is not equivalent
@@ -8981,7 +8985,7 @@ var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
  */
 function assignValue(object, key, value) {
   var objValue = object[key];
-  if (!(hasOwnProperty$8.call(object, key) && eq(objValue, value)) ||
+  if (!(hasOwnProperty$9.call(object, key) && eq(objValue, value)) ||
       (value === undefined && !(key in object))) {
     baseAssignValue(object, key, value);
   }
@@ -9187,7 +9191,7 @@ function createAssigner(assigner) {
 }
 
 /** Used for built-in method references. */
-var objectProto$9 = Object.prototype;
+var objectProto$a = Object.prototype;
 
 /**
  * Checks if `value` is likely a prototype object.
@@ -9198,7 +9202,7 @@ var objectProto$9 = Object.prototype;
  */
 function isPrototype(value) {
   var Ctor = value && value.constructor,
-      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$9;
+      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$a;
 
   return value === proto;
 }
@@ -9237,13 +9241,13 @@ function baseIsArguments(value) {
 }
 
 /** Used for built-in method references. */
-var objectProto$8 = Object.prototype;
+var objectProto$9 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
 
 /** Built-in value references. */
-var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable;
+var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable;
 
 /**
  * Checks if `value` is likely an `arguments` object.
@@ -9264,7 +9268,7 @@ var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable;
  * // => false
  */
 var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
-  return isObjectLike(value) && hasOwnProperty$7.call(value, 'callee') &&
+  return isObjectLike(value) && hasOwnProperty$8.call(value, 'callee') &&
     !propertyIsEnumerable$1.call(value, 'callee');
 };
 
@@ -9437,10 +9441,10 @@ var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
 var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
 
 /** Used for built-in method references. */
-var objectProto$7 = Object.prototype;
+var objectProto$8 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
 
 /**
  * Creates an array of the enumerable property names of the array-like `value`.
@@ -9460,7 +9464,7 @@ function arrayLikeKeys(value, inherited) {
       length = result.length;
 
   for (var key in value) {
-    if ((inherited || hasOwnProperty$6.call(value, key)) &&
+    if ((inherited || hasOwnProperty$7.call(value, key)) &&
         !(skipIndexes && (
            // Safari 9 has enumerable `arguments.length` in strict mode.
            key == 'length' ||
@@ -9495,10 +9499,10 @@ function overArg(func, transform) {
 var nativeKeys = overArg(Object.keys, Object);
 
 /** Used for built-in method references. */
-var objectProto$6 = Object.prototype;
+var objectProto$7 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
 
 /**
  * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
@@ -9513,7 +9517,7 @@ function baseKeys(object) {
   }
   var result = [];
   for (var key in Object(object)) {
-    if (hasOwnProperty$5.call(object, key) && key != 'constructor') {
+    if (hasOwnProperty$6.call(object, key) && key != 'constructor') {
       result.push(key);
     }
   }
@@ -9572,10 +9576,10 @@ function nativeKeysIn(object) {
 }
 
 /** Used for built-in method references. */
-var objectProto$5 = Object.prototype;
+var objectProto$6 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
 
 /**
  * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
@@ -9592,7 +9596,7 @@ function baseKeysIn(object) {
       result = [];
 
   for (var key in object) {
-    if (!(key == 'constructor' && (isProto || !hasOwnProperty$4.call(object, key)))) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty$5.call(object, key)))) {
       result.push(key);
     }
   }
@@ -9686,10 +9690,10 @@ function hashDelete(key) {
 var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
 
 /** Used for built-in method references. */
-var objectProto$4 = Object.prototype;
+var objectProto$5 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
 
 /**
  * Gets the hash value for `key`.
@@ -9706,14 +9710,14 @@ function hashGet(key) {
     var result = data[key];
     return result === HASH_UNDEFINED$2 ? undefined : result;
   }
-  return hasOwnProperty$3.call(data, key) ? data[key] : undefined;
+  return hasOwnProperty$4.call(data, key) ? data[key] : undefined;
 }
 
 /** Used for built-in method references. */
-var objectProto$3 = Object.prototype;
+var objectProto$4 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
 
 /**
  * Checks if a hash value for `key` exists.
@@ -9726,7 +9730,7 @@ var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
  */
 function hashHas(key) {
   var data = this.__data__;
-  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$2.call(data, key);
+  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);
 }
 
 /** Used to stand-in for `undefined` hash values. */
@@ -10371,13 +10375,13 @@ var objectTag$2 = '[object Object]';
 
 /** Used for built-in method references. */
 var funcProto = Function.prototype,
-    objectProto$2 = Object.prototype;
+    objectProto$3 = Object.prototype;
 
 /** Used to resolve the decompiled source of functions. */
 var funcToString = funcProto.toString;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
 
 /** Used to infer the `Object` constructor. */
 var objectCtorString = funcToString.call(Object);
@@ -10418,7 +10422,7 @@ function isPlainObject(value) {
   if (proto === null) {
     return true;
   }
-  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
+  var Ctor = hasOwnProperty$2.call(proto, 'constructor') && proto.constructor;
   return typeof Ctor == 'function' && Ctor instanceof Ctor &&
     funcToString.call(Ctor) == objectCtorString;
 }
@@ -10661,10 +10665,10 @@ function stubArray() {
 }
 
 /** Used for built-in method references. */
-var objectProto$1 = Object.prototype;
+var objectProto$2 = Object.prototype;
 
 /** Built-in value references. */
-var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
@@ -10827,10 +10831,10 @@ if ((DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag$2)
 }
 
 /** Used for built-in method references. */
-var objectProto = Object.prototype;
+var objectProto$1 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
 
 /**
  * Initializes an array clone.
@@ -10844,7 +10848,7 @@ function initCloneArray(array) {
       result = new array.constructor(length);
 
   // Add properties assigned by `RegExp#exec`.
-  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+  if (length && typeof array[0] == 'string' && hasOwnProperty$1.call(array, 'index')) {
     result.index = array.index;
     result.input = array.input;
   }
@@ -11753,6 +11757,12 @@ var merge = createAssigner(function(object, source, srcIndex) {
   baseMerge(object, source, srcIndex);
 });
 
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
 /**
  * The base implementation of `_.unset`.
  *
@@ -11763,8 +11773,47 @@ var merge = createAssigner(function(object, source, srcIndex) {
  */
 function baseUnset(object, path) {
   path = castPath(path, object);
-  object = parent(object, path);
-  return object == null || delete object[toKey(last(path))];
+
+  // Prevent prototype pollution, see: https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+  var index = -1,
+      length = path.length;
+
+  if (!length) {
+    return true;
+  }
+
+  var isRootPrimitive = object == null || (typeof object !== 'object' && typeof object !== 'function');
+
+  while (++index < length) {
+    var key = path[index];
+
+    // skip non-string keys (e.g., Symbols, numbers)
+    if (typeof key !== 'string') {
+      continue;
+    }
+
+    // Always block "__proto__" anywhere in the path if it's not expected
+    if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
+      return false;
+    }
+
+    // Block "constructor.prototype" chains
+    if (key === 'constructor' &&
+        (index + 1) < length &&
+        typeof path[index + 1] === 'string' &&
+        path[index + 1] === 'prototype') {
+
+      // Allow ONLY when the path starts at a primitive root, e.g., _.unset(0, 'constructor.prototype.a')
+      if (isRootPrimitive && index === 0) {
+        continue;
+      }
+
+      return false;
+    }
+  }
+
+  var obj = parent(object, path);
+  return obj == null || delete obj[toKey(last(path))];
 }
 
 /**
@@ -14223,10 +14272,32 @@ function requireUtils$1 () {
 	hasRequiredUtils$1 = 1;
 
 	var formats = /*@__PURE__*/ requireFormats$1();
+	var getSideChannel = requireSideChannel();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
 
+	// Track objects created from arrayLimit overflow using side-channel
+	// Stores the current max numeric index for O(1) lookup
+	var overflowChannel = getSideChannel();
+
+	var markOverflow = function markOverflow(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	    return obj;
+	};
+
+	var isOverflow = function isOverflow(obj) {
+	    return overflowChannel.has(obj);
+	};
+
+	var getMaxIndex = function getMaxIndex(obj) {
+	    return overflowChannel.get(obj);
+	};
+
+	var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	};
+
 	var hexTable = (function () {
 	    var array = [];
 	    for (var i = 0; i < 256; ++i) {
@@ -14276,7 +14347,12 @@ function requireUtils$1 () {
 	        if (isArray(target)) {
 	            target.push(source);
 	        } else if (target && typeof target === 'object') {
-	            if (
+	            if (isOverflow(target)) {
+	                // Add at next numeric index for overflow objects
+	                var newIndex = getMaxIndex(target) + 1;
+	                target[newIndex] = source;
+	                setMaxIndex(target, newIndex);
+	            } else if (
 	                (options && (options.plainObjects || options.allowPrototypes))
 	                || !has.call(Object.prototype, source)
 	            ) {
@@ -14290,6 +14366,18 @@ function requireUtils$1 () {
 	    }
 
 	    if (!target || typeof target !== 'object') {
+	        if (isOverflow(source)) {
+	            // Create new object with target at 0, source values shifted by 1
+	            var sourceKeys = Object.keys(source);
+	            var result = options && options.plainObjects
+	                ? { __proto__: null, 0: target }
+	                : { 0: target };
+	            for (var m = 0; m < sourceKeys.length; m++) {
+	                var oldKey = parseInt(sourceKeys[m], 10);
+	                result[oldKey + 1] = source[sourceKeys[m]];
+	            }
+	            return markOverflow(result, getMaxIndex(source) + 1);
+	        }
 	        return [target].concat(source);
 	    }
 
@@ -14461,8 +14549,20 @@ function requireUtils$1 () {
 	    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
 	};
 
-	var combine = function combine(a, b) {
-	    return [].concat(a, b);
+	var combine = function combine(a, b, arrayLimit, plainObjects) {
+	    // If 'a' is already an overflow object, add to it
+	    if (isOverflow(a)) {
+	        var newIndex = getMaxIndex(a) + 1;
+	        a[newIndex] = b;
+	        setMaxIndex(a, newIndex);
+	        return a;
+	    }
+
+	    var result = [].concat(a, b);
+	    if (result.length > arrayLimit) {
+	        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
+	    }
+	    return result;
 	};
 
 	var maybeMap = function maybeMap(val, fn) {
@@ -14484,6 +14584,7 @@ function requireUtils$1 () {
 	    decode: decode,
 	    encode: encode,
 	    isBuffer: isBuffer,
+	    isOverflow: isOverflow,
 	    isRegExp: isRegExp,
 	    maybeMap: maybeMap,
 	    merge: merge
@@ -14970,16 +15071,18 @@ function requireParse$1 () {
 	        } else {
 	            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
 
-	            val = utils.maybeMap(
-	                parseArrayValue(
-	                    part.slice(pos + 1),
-	                    options,
-	                    isArray(obj[key]) ? obj[key].length : 0
-	                ),
-	                function (encodedVal) {
-	                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');
-	                }
-	            );
+	            if (key !== null) {
+	                val = utils.maybeMap(
+	                    parseArrayValue(
+	                        part.slice(pos + 1),
+	                        options,
+	                        isArray(obj[key]) ? obj[key].length : 0
+	                    ),
+	                    function (encodedVal) {
+	                        return options.decoder(encodedVal, defaults.decoder, charset, 'value');
+	                    }
+	                );
+	            }
 	        }
 
 	        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
@@ -14990,11 +15093,18 @@ function requireParse$1 () {
 	            val = isArray(val) ? [val] : val;
 	        }
 
-	        var existing = has.call(obj, key);
-	        if (existing && options.duplicates === 'combine') {
-	            obj[key] = utils.combine(obj[key], val);
-	        } else if (!existing || options.duplicates === 'last') {
-	            obj[key] = val;
+	        if (key !== null) {
+	            var existing = has.call(obj, key);
+	            if (existing && options.duplicates === 'combine') {
+	                obj[key] = utils.combine(
+	                    obj[key],
+	                    val,
+	                    options.arrayLimit,
+	                    options.plainObjects
+	                );
+	            } else if (!existing || options.duplicates === 'last') {
+	                obj[key] = val;
+	            }
 	        }
 	    }
 
@@ -15015,9 +15125,19 @@ function requireParse$1 () {
 	        var root = chain[i];
 
 	        if (root === '[]' && options.parseArrays) {
-	            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
-	                ? []
-	                : utils.combine([], leaf);
+	            if (utils.isOverflow(leaf)) {
+	                // leaf is already an overflow object, preserve it
+	                obj = leaf;
+	            } else {
+	                obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
+	                    ? []
+	                    : utils.combine(
+	                        [],
+	                        leaf,
+	                        options.arrayLimit,
+	                        options.plainObjects
+	                    );
+	            }
 	        } else {
 	            obj = options.plainObjects ? { __proto__: null } : {};
 	            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
@@ -15045,29 +15165,28 @@ function requireParse$1 () {
 	    return leaf;
 	};
 
-	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
-	    if (!givenKey) {
-	        return;
-	    }
-
-	    // Transform dot notation to bracket notation
+	var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
 	    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
 
-	    // The regex chunks
+	    if (options.depth <= 0) {
+	        if (!options.plainObjects && has.call(Object.prototype, key)) {
+	            if (!options.allowPrototypes) {
+	                return;
+	            }
+	        }
+
+	        return [key];
+	    }
 
 	    var brackets = /(\[[^[\]]*])/;
 	    var child = /(\[[^[\]]*])/g;
 
-	    // Get the parent
-
-	    var segment = options.depth > 0 && brackets.exec(key);
+	    var segment = brackets.exec(key);
 	    var parent = segment ? key.slice(0, segment.index) : key;
 
-	    // Stash the parent if it exists
-
 	    var keys = [];
+
 	    if (parent) {
-	        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
 	        if (!options.plainObjects && has.call(Object.prototype, parent)) {
 	            if (!options.allowPrototypes) {
 	                return;
@@ -15077,28 +15196,42 @@ function requireParse$1 () {
 	        keys.push(parent);
 	    }
 
-	    // Loop through children appending to the array until we hit depth
-
 	    var i = 0;
-	    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
+	    while ((segment = child.exec(key)) !== null && i < options.depth) {
 	        i += 1;
-	        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+
+	        var segmentContent = segment[1].slice(1, -1);
+	        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
 	            if (!options.allowPrototypes) {
 	                return;
 	            }
 	        }
+
 	        keys.push(segment[1]);
 	    }
 
-	    // If there's a remainder, check strictDepth option for throw, else just add whatever is left
-
 	    if (segment) {
 	        if (options.strictDepth === true) {
 	            throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
 	        }
+
 	        keys.push('[' + key.slice(segment.index) + ']');
 	    }
 
+	    return keys;
+	};
+
+	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+	    if (!givenKey) {
+	        return;
+	    }
+
+	    var keys = splitKeyIntoSegments(givenKey, options);
+
+	    if (!keys) {
+	        return;
+	    }
+
 	    return parseObject(keys, val, options, valuesParsed);
 	};
 
@@ -21969,13 +22102,13 @@ function requireDataType () {
 	            case "number":
 	                gen
 	                    .elseIf((0, codegen_1._) `${dataType} == "boolean" || ${data} === null
-              || (${dataType} == "string" && ${data} && ${data}.trim() && ${data} == +${data})`)
+              || (${dataType} == "string" && ${data} && ${data} == +${data})`)
 	                    .assign(coerced, (0, codegen_1._) `+${data}`);
 	                return;
 	            case "integer":
 	                gen
 	                    .elseIf((0, codegen_1._) `${dataType} === "boolean" || ${data} === null
-              || (${dataType} === "string" && ${data} && ${data}.trim() && ${data} == +${data} && !(${data} % 1))`)
+              || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`)
 	                    .assign(coerced, (0, codegen_1._) `+${data}`);
 	                return;
 	            case "boolean":
@@ -32567,24 +32700,71 @@ class Comparator {
     }
 }
 
-var version = "1.11.0";
-var packageJson = {
-	version: version};
-
-const readAndParse = async (filename) => {
-    const file = await require$$3$2.promises.readFile(filename, { encoding: "utf-8" });
-    try {
-        return JSON.parse(file);
+const MAX_EXIT_CODE = 255;
+const defaultDependencies = {
+    readFile: (path) => require$$3$2.promises.readFile(path, { encoding: "utf-8" }),
+    fetch: (url) => fetch(url),
+    output: (message) => console.log(message),
+    createComparator: (oas) => new Comparator(oas),
+};
+class Runner {
+    deps;
+    constructor(deps = {}) {
+        this.deps = { ...defaultDependencies, ...deps };
     }
-    catch (error) {
+    isUrl(path) {
         try {
-            return jsYaml.load(file);
+            const url = new URL(path);
+            return url.protocol === "http:" || url.protocol === "https:";
         }
-        catch (_err) {
-            throw error;
+        catch {
+            return false;
         }
     }
-};
+    async readContent(path) {
+        if (this.isUrl(path)) {
+            const response = await this.deps.fetch(path);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return response.text();
+        }
+        return this.deps.readFile(path);
+    }
+    parseContent(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            try {
+                return jsYaml.load(content);
+            }
+            catch (_err) {
+                throw error;
+            }
+        }
+    }
+    async readAndParse(path) {
+        const content = await this.readContent(path);
+        return this.parseContent(content);
+    }
+    async run(oasPath, pactPaths) {
+        const oas = (await this.readAndParse(oasPath));
+        const comparator = this.deps.createComparator(oas);
+        let errors = 0;
+        for (const pactPath of pactPaths) {
+            const pact = await this.readAndParse(pactPath);
+            const results = [];
+            for await (const result of comparator.compare(pact)) {
+                results.push(result);
+            }
+            errors += results.some((r) => r.type === "error") ? 1 : 0;
+            this.deps.output(JSON.stringify(results));
+        }
+        return Math.min(errors, MAX_EXIT_CODE);
+    }
+}
+
 program
     .version(packageJson.version)
     .command("opc")
@@ -32593,22 +32773,12 @@ program
 Comparison output is presented as ND-JSON, with one line per Pact file.
 
 The exit code equals the number of Pact files with errors (not the number of errors in one comparison).`)
-    .argument("<oas>", "path to OAS file")
-    .argument("<pact...>", "path(s) to Pact file(s)")
+    .argument("<oas>", "path or URL to OAD file")
+    .argument("<pact...>", "path(s) or URL(s) to Pact file(s)")
     .action(async (oasPath, pactPaths) => {
-    const oas = await readAndParse(oasPath);
-    const comparator = new Comparator(oas);
-    let errors = 0;
-    for (const pactPath of pactPaths) {
-        const pact = await readAndParse(pactPath);
-        const results = [];
-        for await (const result of comparator.compare(pact)) {
-            results.push(result);
-        }
-        errors += results.some((r) => r.type === "error") ? 1 : 0;
-        console.log(JSON.stringify(results));
-    }
-    process.exit(errors);
+    const runner = new Runner();
+    const exitCode = await runner.run(oasPath, pactPaths);
+    process.exit(exitCode);
 })
     .parse(process.argv);
 //# sourceMappingURL=cli.cjs.map