neo-cmp-cli 1.8.6-beta.2 → 1.8.6-beta.5

package/dist/node_modules/@babel/runtime/helpers/OverloadYield.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var OverloadYield = require('../../../../_virtual/OverloadYield.js');
+
+var hasRequiredOverloadYield;
+
+function requireOverloadYield () {
+	if (hasRequiredOverloadYield) return OverloadYield.__module.exports;
+	hasRequiredOverloadYield = 1;
+	(function (module) {
+		function _OverloadYield(e, d) {
+		  this.v = e, this.k = d;
+		}
+		module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (OverloadYield.__module));
+	return OverloadYield.__module.exports;
+}
+
+exports.__require = requireOverloadYield;

package/dist/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js

@@ -0,0 +1,29 @@
+'use strict';
+
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+
+module.exports = _asyncToGenerator;

package/dist/node_modules/@babel/runtime/helpers/esm/extends.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+module.exports = _extends;

package/dist/node_modules/@babel/runtime/helpers/regenerator.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var regenerator = require('../../../../_virtual/regenerator.js');
+var regeneratorDefine = require('./regeneratorDefine.js');
+
+var hasRequiredRegenerator;
+
+function requireRegenerator () {
+	if (hasRequiredRegenerator) return regenerator.__module.exports;
+	hasRequiredRegenerator = 1;
+	(function (module) {
+		var regeneratorDefine$1 = regeneratorDefine.__require();
+		function _regenerator() {
+		  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+		  var e,
+		    t,
+		    r = "function" == typeof Symbol ? Symbol : {},
+		    n = r.iterator || "@@iterator",
+		    o = r.toStringTag || "@@toStringTag";
+		  function i(r, n, o, i) {
+		    var c = n && n.prototype instanceof Generator ? n : Generator,
+		      u = Object.create(c.prototype);
+		    return regeneratorDefine$1(u, "_invoke", function (r, n, o) {
+		      var i,
+		        c,
+		        u,
+		        f = 0,
+		        p = o || [],
+		        y = false,
+		        G = {
+		          p: 0,
+		          n: 0,
+		          v: e,
+		          a: d,
+		          f: d.bind(e, 4),
+		          d: function d(t, r) {
+		            return i = t, c = 0, u = e, G.n = r, a;
+		          }
+		        };
+		      function d(r, n) {
+		        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+		          var o,
+		            i = p[t],
+		            d = G.p,
+		            l = i[2];
+		          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+		        }
+		        if (o || r > 1) return a;
+		        throw y = true, n;
+		      }
+		      return function (o, p, l) {
+		        if (f > 1) throw TypeError("Generator is already running");
+		        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+		          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+		          try {
+		            if (f = 2, i) {
+		              if (c || (o = "next"), t = i[o]) {
+		                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+		                if (!t.done) return t;
+		                u = t.value, c < 2 && (c = 0);
+		              } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+		              i = e;
+		            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+		          } catch (t) {
+		            i = e, c = 1, u = t;
+		          } finally {
+		            f = 1;
+		          }
+		        }
+		        return {
+		          value: t,
+		          done: y
+		        };
+		      };
+		    }(r, o, i), true), u;
+		  }
+		  var a = {};
+		  function Generator() {}
+		  function GeneratorFunction() {}
+		  function GeneratorFunctionPrototype() {}
+		  t = Object.getPrototypeOf;
+		  var c = [][n] ? t(t([][n]())) : (regeneratorDefine$1(t = {}, n, function () {
+		      return this;
+		    }), t),
+		    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+		  function f(e) {
+		    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine$1(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+		  }
+		  return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine$1(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine$1(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine$1(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine$1(u), regeneratorDefine$1(u, o, "Generator"), regeneratorDefine$1(u, n, function () {
+		    return this;
+		  }), regeneratorDefine$1(u, "toString", function () {
+		    return "[object Generator]";
+		  }), (module.exports = _regenerator = function _regenerator() {
+		    return {
+		      w: i,
+		      m: f
+		    };
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+		}
+		module.exports = _regenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regenerator.__module));
+	return regenerator.__module.exports;
+}
+
+exports.__require = requireRegenerator;

package/dist/node_modules/@babel/runtime/helpers/regeneratorAsync.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var regeneratorAsync = require('../../../../_virtual/regeneratorAsync.js');
+var regeneratorAsyncGen = require('./regeneratorAsyncGen.js');
+
+var hasRequiredRegeneratorAsync;
+
+function requireRegeneratorAsync () {
+	if (hasRequiredRegeneratorAsync) return regeneratorAsync.__module.exports;
+	hasRequiredRegeneratorAsync = 1;
+	(function (module) {
+		var regeneratorAsyncGen$1 = regeneratorAsyncGen.__require();
+		function _regeneratorAsync(n, e, r, t, o) {
+		  var a = regeneratorAsyncGen$1(n, e, r, t, o);
+		  return a.next().then(function (n) {
+		    return n.done ? n.value : a.next();
+		  });
+		}
+		module.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorAsync.__module));
+	return regeneratorAsync.__module.exports;
+}
+
+exports.__require = requireRegeneratorAsync;

package/dist/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var regeneratorAsyncGen = require('../../../../_virtual/regeneratorAsyncGen.js');
+var regenerator = require('./regenerator.js');
+var regeneratorAsyncIterator = require('./regeneratorAsyncIterator.js');
+
+var hasRequiredRegeneratorAsyncGen;
+
+function requireRegeneratorAsyncGen () {
+	if (hasRequiredRegeneratorAsyncGen) return regeneratorAsyncGen.__module.exports;
+	hasRequiredRegeneratorAsyncGen = 1;
+	(function (module) {
+		var regenerator$1 = regenerator.__require();
+		var regeneratorAsyncIterator$1 = regeneratorAsyncIterator.__require();
+		function _regeneratorAsyncGen(r, e, t, o, n) {
+		  return new regeneratorAsyncIterator$1(regenerator$1().w(r, e, t, o), n || Promise);
+		}
+		module.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorAsyncGen.__module));
+	return regeneratorAsyncGen.__module.exports;
+}
+
+exports.__require = requireRegeneratorAsyncGen;

package/dist/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var regeneratorAsyncIterator = require('../../../../_virtual/regeneratorAsyncIterator.js');
+var OverloadYield = require('./OverloadYield.js');
+var regeneratorDefine = require('./regeneratorDefine.js');
+
+var hasRequiredRegeneratorAsyncIterator;
+
+function requireRegeneratorAsyncIterator () {
+	if (hasRequiredRegeneratorAsyncIterator) return regeneratorAsyncIterator.__module.exports;
+	hasRequiredRegeneratorAsyncIterator = 1;
+	(function (module) {
+		var OverloadYield$1 = OverloadYield.__require();
+		var regeneratorDefine$1 = regeneratorDefine.__require();
+		function AsyncIterator(t, e) {
+		  function n(r, o, i, f) {
+		    try {
+		      var c = t[r](o),
+		        u = c.value;
+		      return u instanceof OverloadYield$1 ? e.resolve(u.v).then(function (t) {
+		        n("next", t, i, f);
+		      }, function (t) {
+		        n("throw", t, i, f);
+		      }) : e.resolve(u).then(function (t) {
+		        c.value = t, i(c);
+		      }, function (t) {
+		        return n("throw", t, i, f);
+		      });
+		    } catch (t) {
+		      f(t);
+		    }
+		  }
+		  var r;
+		  this.next || (regeneratorDefine$1(AsyncIterator.prototype), regeneratorDefine$1(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () {
+		    return this;
+		  })), regeneratorDefine$1(this, "_invoke", function (t, o, i) {
+		    function f() {
+		      return new e(function (e, r) {
+		        n(t, i, e, r);
+		      });
+		    }
+		    return r = r ? r.then(f, f) : f();
+		  }, true);
+		}
+		module.exports = AsyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorAsyncIterator.__module));
+	return regeneratorAsyncIterator.__module.exports;
+}
+
+exports.__require = requireRegeneratorAsyncIterator;

package/dist/node_modules/@babel/runtime/helpers/regeneratorDefine.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var regeneratorDefine = require('../../../../_virtual/regeneratorDefine.js');
+
+var hasRequiredRegeneratorDefine;
+
+function requireRegeneratorDefine () {
+	if (hasRequiredRegeneratorDefine) return regeneratorDefine.__module.exports;
+	hasRequiredRegeneratorDefine = 1;
+	(function (module) {
+		function _regeneratorDefine(e, r, n, t) {
+		  var i = Object.defineProperty;
+		  try {
+		    i({}, "", {});
+		  } catch (e) {
+		    i = 0;
+		  }
+		  module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
+		    function o(r, n) {
+		      _regeneratorDefine(e, r, function (e) {
+		        return this._invoke(r, n, e);
+		      });
+		    }
+		    r ? i ? i(e, r, {
+		      value: n,
+		      enumerable: !t,
+		      configurable: !t,
+		      writable: !t
+		    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t);
+		}
+		module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorDefine.__module));
+	return regeneratorDefine.__module.exports;
+}
+
+exports.__require = requireRegeneratorDefine;

package/dist/node_modules/@babel/runtime/helpers/regeneratorKeys.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var regeneratorKeys = require('../../../../_virtual/regeneratorKeys.js');
+
+var hasRequiredRegeneratorKeys;
+
+function requireRegeneratorKeys () {
+	if (hasRequiredRegeneratorKeys) return regeneratorKeys.__module.exports;
+	hasRequiredRegeneratorKeys = 1;
+	(function (module) {
+		function _regeneratorKeys(e) {
+		  var n = Object(e),
+		    r = [];
+		  for (var t in n) r.unshift(t);
+		  return function e() {
+		    for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = false, e;
+		    return e.done = true, e;
+		  };
+		}
+		module.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorKeys.__module));
+	return regeneratorKeys.__module.exports;
+}
+
+exports.__require = requireRegeneratorKeys;

package/dist/node_modules/@babel/runtime/helpers/regeneratorRuntime.js

@@ -0,0 +1,98 @@
+'use strict';
+
+var regeneratorRuntime = require('../../../../_virtual/regeneratorRuntime.js');
+var OverloadYield = require('./OverloadYield.js');
+var regenerator = require('./regenerator.js');
+var regeneratorAsync = require('./regeneratorAsync.js');
+var regeneratorAsyncGen = require('./regeneratorAsyncGen.js');
+var regeneratorAsyncIterator = require('./regeneratorAsyncIterator.js');
+var regeneratorKeys = require('./regeneratorKeys.js');
+var regeneratorValues = require('./regeneratorValues.js');
+
+var hasRequiredRegeneratorRuntime;
+
+function requireRegeneratorRuntime () {
+	if (hasRequiredRegeneratorRuntime) return regeneratorRuntime.__module.exports;
+	hasRequiredRegeneratorRuntime = 1;
+	(function (module) {
+		var OverloadYield$1 = OverloadYield.__require();
+		var regenerator$1 = regenerator.__require();
+		var regeneratorAsync$1 = regeneratorAsync.__require();
+		var regeneratorAsyncGen$1 = regeneratorAsyncGen.__require();
+		var regeneratorAsyncIterator$1 = regeneratorAsyncIterator.__require();
+		var regeneratorKeys$1 = regeneratorKeys.__require();
+		var regeneratorValues$1 = regeneratorValues.__require();
+		function _regeneratorRuntime() {
+
+		  var r = regenerator$1(),
+		    e = r.m(_regeneratorRuntime),
+		    t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
+		  function n(r) {
+		    var e = "function" == typeof r && r.constructor;
+		    return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name));
+		  }
+		  var o = {
+		    "throw": 1,
+		    "return": 2,
+		    "break": 3,
+		    "continue": 3
+		  };
+		  function a(r) {
+		    var e, t;
+		    return function (n) {
+		      e || (e = {
+		        stop: function stop() {
+		          return t(n.a, 2);
+		        },
+		        "catch": function _catch() {
+		          return n.v;
+		        },
+		        abrupt: function abrupt(r, e) {
+		          return t(n.a, o[r], e);
+		        },
+		        delegateYield: function delegateYield(r, o, a) {
+		          return e.resultName = o, t(n.d, regeneratorValues$1(r), a);
+		        },
+		        finish: function finish(r) {
+		          return t(n.f, r);
+		        }
+		      }, t = function t(r, _t, o) {
+		        n.p = e.prev, n.n = e.next;
+		        try {
+		          return r(_t, o);
+		        } finally {
+		          e.next = n.n;
+		        }
+		      }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;
+		      try {
+		        return r.call(this, e);
+		      } finally {
+		        n.p = e.prev, n.n = e.next;
+		      }
+		    };
+		  }
+		  return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+		    return {
+		      wrap: function wrap(e, t, n, o) {
+		        return r.w(a(e), t, n, o && o.reverse());
+		      },
+		      isGeneratorFunction: n,
+		      mark: r.m,
+		      awrap: function awrap(r, e) {
+		        return new OverloadYield$1(r, e);
+		      },
+		      AsyncIterator: regeneratorAsyncIterator$1,
+		      async: function async(r, e, t, o, u) {
+		        return (n(e) ? regeneratorAsyncGen$1 : regeneratorAsync$1)(a(r), e, t, o, u);
+		      },
+		      keys: regeneratorKeys$1,
+		      values: regeneratorValues$1
+		    };
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+		}
+		module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorRuntime.__module));
+	return regeneratorRuntime.__module.exports;
+}
+
+exports.__require = requireRegeneratorRuntime;

package/dist/node_modules/@babel/runtime/helpers/regeneratorValues.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var regeneratorValues = require('../../../../_virtual/regeneratorValues.js');
+var _typeof = require('./typeof.js');
+
+var hasRequiredRegeneratorValues;
+
+function requireRegeneratorValues () {
+	if (hasRequiredRegeneratorValues) return regeneratorValues.__module.exports;
+	hasRequiredRegeneratorValues = 1;
+	(function (module) {
+		var _typeof$1 = _typeof.__require()["default"];
+		function _regeneratorValues(e) {
+		  if (null != e) {
+		    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+		      r = 0;
+		    if (t) return t.call(e);
+		    if ("function" == typeof e.next) return e;
+		    if (!isNaN(e.length)) return {
+		      next: function next() {
+		        return e && r >= e.length && (e = void 0), {
+		          value: e && e[r++],
+		          done: !e
+		        };
+		      }
+		    };
+		  }
+		  throw new TypeError(_typeof$1(e) + " is not iterable");
+		}
+		module.exports = _regeneratorValues, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (regeneratorValues.__module));
+	return regeneratorValues.__module.exports;
+}
+
+exports.__require = requireRegeneratorValues;

package/dist/node_modules/@babel/runtime/helpers/typeof.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var _typeof = require('../../../../_virtual/typeof.js');
+
+var hasRequired_typeof;
+
+function require_typeof () {
+	if (hasRequired_typeof) return _typeof.__module.exports;
+	hasRequired_typeof = 1;
+	(function (module) {
+		function _typeof(o) {
+		  "@babel/helpers - typeof";
+
+		  return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+		    return typeof o;
+		  } : function (o) {
+		    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+		  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
+		}
+		module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+	} (_typeof.__module));
+	return _typeof.__module.exports;
+}
+
+exports.__require = require_typeof;

package/dist/node_modules/@babel/runtime/regenerator/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var regeneratorRuntime$1 = require('../helpers/regeneratorRuntime.js');
+
+var regenerator;
+var hasRequiredRegenerator;
+
+function requireRegenerator () {
+	if (hasRequiredRegenerator) return regenerator;
+	hasRequiredRegenerator = 1;
+	// TODO(Babel 8): Remove this file.
+
+	var runtime = regeneratorRuntime$1.__require()();
+	regenerator = runtime;
+
+	// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
+	try {
+	  regeneratorRuntime = runtime;
+	} catch (accidentalStrictMode) {
+	  if (typeof globalThis === "object") {
+	    globalThis.regeneratorRuntime = runtime;
+	  } else {
+	    Function("r", "regeneratorRuntime = r")(runtime);
+	  }
+	}
+	return regenerator;
+}
+
+exports.__require = requireRegenerator;

package/dist/node_modules/buffer-from/index.js

@@ -0,0 +1,57 @@
+'use strict';
+
+/* eslint-disable node/no-deprecated-api */
+
+var bufferFrom_1;
+var hasRequiredBufferFrom;
+
+function requireBufferFrom () {
+	if (hasRequiredBufferFrom) return bufferFrom_1;
+	hasRequiredBufferFrom = 1;
+	var toString = Object.prototype.toString;
+	var isModern = typeof Buffer !== 'undefined' && typeof Buffer.alloc === 'function' && typeof Buffer.allocUnsafe === 'function' && typeof Buffer.from === 'function';
+	function isArrayBuffer(input) {
+	  return toString.call(input).slice(8, -1) === 'ArrayBuffer';
+	}
+	function fromArrayBuffer(obj, byteOffset, length) {
+	  byteOffset >>>= 0;
+	  var maxLength = obj.byteLength - byteOffset;
+	  if (maxLength < 0) {
+	    throw new RangeError("'offset' is out of bounds");
+	  }
+	  if (length === undefined) {
+	    length = maxLength;
+	  } else {
+	    length >>>= 0;
+	    if (length > maxLength) {
+	      throw new RangeError("'length' is out of bounds");
+	    }
+	  }
+	  return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
+	}
+	function fromString(string, encoding) {
+	  if (typeof encoding !== 'string' || encoding === '') {
+	    encoding = 'utf8';
+	  }
+	  if (!Buffer.isEncoding(encoding)) {
+	    throw new TypeError('"encoding" must be a valid string encoding');
+	  }
+	  return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
+	}
+	function bufferFrom(value, encodingOrOffset, length) {
+	  if (typeof value === 'number') {
+	    throw new TypeError('"value" argument must not be a number');
+	  }
+	  if (isArrayBuffer(value)) {
+	    return fromArrayBuffer(value, encodingOrOffset, length);
+	  }
+	  if (typeof value === 'string') {
+	    return fromString(value, encodingOrOffset);
+	  }
+	  return isModern ? Buffer.from(value) : new Buffer(value);
+	}
+	bufferFrom_1 = bufferFrom;
+	return bufferFrom_1;
+}
+
+exports.__require = requireBufferFrom;