goatlint-runtime 0.125.0

package/src/helpers/esm/usingCtx.js

@@ -0,0 +1,59 @@
+function _usingCtx() {
+  var r = "function" == typeof SuppressedError ? SuppressedError : function (r, e) {
+      var n = Error();
+      return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+    },
+    e = {},
+    n = [];
+  function using(r, e) {
+    if (null != e) {
+      if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+      if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+      if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+      t && (o = function o() {
+        try {
+          t.call(e);
+        } catch (r) {
+          return Promise.reject(r);
+        }
+      }), n.push({
+        v: e,
+        d: o,
+        a: r
+      });
+    } else r && n.push({
+      d: e,
+      a: r
+    });
+    return e;
+  }
+  return {
+    e: e,
+    u: using.bind(null, !1),
+    a: using.bind(null, !0),
+    d: function d() {
+      var o,
+        t = this.e,
+        s = 0;
+      function next() {
+        for (; o = n.pop();) try {
+          if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+          if (o.d) {
+            var r = o.d.call(o.v);
+            if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+          } else s |= 1;
+        } catch (r) {
+          return err(r);
+        }
+        if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+        if (t !== e) throw t;
+      }
+      function err(n) {
+        return t = t !== e ? new r(n, t) : n, next();
+      }
+      return next();
+    }
+  };
+}
+export { _usingCtx as default };

package/src/helpers/esm/wrapAsyncGenerator.js

@@ -0,0 +1,69 @@
+import OverloadYield from "./OverloadYield.js";
+function _wrapAsyncGenerator(e) {
+  return function () {
+    return new AsyncGenerator(e.apply(this, arguments));
+  };
+}
+function AsyncGenerator(e) {
+  var r, t;
+  function resume(r, t) {
+    try {
+      var n = e[r](t),
+        o = n.value,
+        u = o instanceof OverloadYield;
+      Promise.resolve(u ? o.v : o).then(function (t) {
+        if (u) {
+          var i = "return" === r ? "return" : "next";
+          if (!o.k || t.done) return resume(i, t);
+          t = e[i](t).value;
+        }
+        settle(n.done ? "return" : "normal", t);
+      }, function (e) {
+        resume("throw", e);
+      });
+    } catch (e) {
+      settle("throw", e);
+    }
+  }
+  function settle(e, n) {
+    switch (e) {
+      case "return":
+        r.resolve({
+          value: n,
+          done: !0
+        });
+        break;
+      case "throw":
+        r.reject(n);
+        break;
+      default:
+        r.resolve({
+          value: n,
+          done: !1
+        });
+    }
+    (r = r.next) ? resume(r.key, r.arg) : t = null;
+  }
+  this._invoke = function (e, n) {
+    return new Promise(function (o, u) {
+      var i = {
+        key: e,
+        arg: n,
+        resolve: o,
+        reject: u,
+        next: null
+      };
+      t ? t = t.next = i : (r = t = i, resume(e, n));
+    });
+  }, "function" != typeof e["return"] && (this["return"] = void 0);
+}
+AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+  return this;
+}, AsyncGenerator.prototype.next = function (e) {
+  return this._invoke("next", e);
+}, AsyncGenerator.prototype["throw"] = function (e) {
+  return this._invoke("throw", e);
+}, AsyncGenerator.prototype["return"] = function (e) {
+  return this._invoke("return", e);
+};
+export { _wrapAsyncGenerator as default };

package/src/helpers/esm/wrapNativeSuper.js

@@ -0,0 +1,27 @@
+import getPrototypeOf from "./getPrototypeOf.js";
+import setPrototypeOf from "./setPrototypeOf.js";
+import isNativeFunction from "./isNativeFunction.js";
+import construct from "./construct.js";
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function _wrapNativeSuper(t) {
+    if (null === t || !isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return construct(t, arguments, getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+export { _wrapNativeSuper as default };

package/src/helpers/esm/wrapRegExp.js

@@ -0,0 +1,51 @@
+import _typeof from "./typeof.js";
+import setPrototypeOf from "./setPrototypeOf.js";
+import inherits from "./inherits.js";
+function _wrapRegExp() {
+  _wrapRegExp = function _wrapRegExp(e, r) {
+    return new BabelRegExp(e, void 0, r);
+  };
+  var e = RegExp.prototype,
+    r = new WeakMap();
+  function BabelRegExp(e, t, p) {
+    var o = RegExp(e, t);
+    return r.set(o, p || r.get(e)), setPrototypeOf(o, BabelRegExp.prototype);
+  }
+  function buildGroups(e, t) {
+    var p = r.get(t);
+    return Object.keys(p).reduce(function (r, t) {
+      var o = p[t];
+      if ("number" == typeof o) r[t] = e[o];else {
+        for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++;
+        r[t] = e[o[i]];
+      }
+      return r;
+    }, Object.create(null));
+  }
+  return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) {
+    var t = e.exec.call(this, r);
+    if (t) {
+      t.groups = buildGroups(t, this);
+      var p = t.indices;
+      p && (p.groups = buildGroups(p, this));
+    }
+    return t;
+  }, BabelRegExp.prototype[Symbol.replace] = function (t, p) {
+    if ("string" == typeof p) {
+      var o = r.get(this);
+      return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)>/g, function (e, r) {
+        var t = o[r];
+        return "$" + (Array.isArray(t) ? t.join("$") : t);
+      }));
+    }
+    if ("function" == typeof p) {
+      var i = this;
+      return e[Symbol.replace].call(this, t, function () {
+        var e = arguments;
+        return "object" != _typeof(e[e.length - 1]) && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e);
+      });
+    }
+    return e[Symbol.replace].call(this, t, p);
+  }, _wrapRegExp.apply(this, arguments);
+}
+export { _wrapRegExp as default };

package/src/helpers/esm/writeOnlyError.js

@@ -0,0 +1,4 @@
+function _writeOnlyError(r) {
+  throw new TypeError('"' + r + '" is write-only');
+}
+export { _writeOnlyError as default };

package/src/helpers/extends.js

@@ -0,0 +1,10 @@
+function _extends() {
+  return module.exports = _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;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
+}
+module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/get.js

@@ -0,0 +1,11 @@
+var superPropBase = require("./superPropBase.js");
+function _get() {
+  return module.exports = _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
+    var p = superPropBase(e, t);
+    if (p) {
+      var n = Object.getOwnPropertyDescriptor(p, t);
+      return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
+    }
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _get.apply(null, arguments);
+}
+module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/getPrototypeOf.js

@@ -0,0 +1,6 @@
+function _getPrototypeOf(t) {
+  return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _getPrototypeOf(t);
+}
+module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/identity.js

@@ -0,0 +1,4 @@
+function _identity(t) {
+  return t;
+}
+module.exports = _identity, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/importDeferProxy.js

@@ -0,0 +1,27 @@
+function _importDeferProxy(e) {
+  var t = null,
+    constValue = function constValue(e) {
+      return function () {
+        return e;
+      };
+    },
+    proxy = function proxy(r) {
+      return function (n, o, f) {
+        return null === t && (t = e()), r(t, o, f);
+      };
+    };
+  return new Proxy({}, {
+    defineProperty: constValue(!1),
+    deleteProperty: constValue(!1),
+    get: proxy(Reflect.get),
+    getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor),
+    getPrototypeOf: constValue(null),
+    isExtensible: constValue(!1),
+    has: proxy(Reflect.has),
+    ownKeys: proxy(Reflect.ownKeys),
+    preventExtensions: constValue(!0),
+    set: constValue(!1),
+    setPrototypeOf: constValue(!1)
+  });
+}
+module.exports = _importDeferProxy, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/inherits.js

@@ -0,0 +1,14 @@
+var setPrototypeOf = require("./setPrototypeOf.js");
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && setPrototypeOf(t, e);
+}
+module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/inheritsLoose.js

@@ -0,0 +1,5 @@
+var setPrototypeOf = require("./setPrototypeOf.js");
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);
+}
+module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/initializerDefineProperty.js

@@ -0,0 +1,9 @@
+function _initializerDefineProperty(e, i, r, l) {
+  r && Object.defineProperty(e, i, {
+    enumerable: r.enumerable,
+    configurable: r.configurable,
+    writable: r.writable,
+    value: r.initializer ? r.initializer.call(l) : void 0
+  });
+}
+module.exports = _initializerDefineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/initializerWarningHelper.js

@@ -0,0 +1,4 @@
+function _initializerWarningHelper(r, e) {
+  throw Error("Decorating class property failed. Please ensure that transform-class-properties is enabled and runs after the decorators transform.");
+}
+module.exports = _initializerWarningHelper, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/instanceof.js

@@ -0,0 +1,4 @@
+function _instanceof(n, e) {
+  return null != e && "undefined" != typeof Symbol && e[Symbol.hasInstance] ? !!e[Symbol.hasInstance](n) : n instanceof e;
+}
+module.exports = _instanceof, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/interopRequireDefault.js

@@ -0,0 +1,6 @@
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : {
+    "default": e
+  };
+}
+module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/interopRequireWildcard.js

@@ -0,0 +1,27 @@
+var _typeof = require("./typeof.js")["default"];
+function _getRequireWildcardCache(e) {
+  if ("function" != typeof WeakMap) return null;
+  var r = new WeakMap(),
+    t = new WeakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache(e) {
+    return e ? t : r;
+  })(e);
+}
+function _interopRequireWildcard(e, r) {
+  if (!r && e && e.__esModule) return e;
+  if (null === e || "object" != _typeof(e) && "function" != typeof e) return {
+    "default": e
+  };
+  var t = _getRequireWildcardCache(r);
+  if (t && t.has(e)) return t.get(e);
+  var n = {
+      __proto__: null
+    },
+    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
+    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+  }
+  return n["default"] = e, t && t.set(e, n), n;
+}
+module.exports = _interopRequireWildcard, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/isNativeFunction.js

@@ -0,0 +1,8 @@
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/isNativeReflectConstruct.js

@@ -0,0 +1,9 @@
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (module.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+}
+module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/iterableToArray.js

@@ -0,0 +1,4 @@
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/iterableToArrayLimit.js

@@ -0,0 +1,28 @@
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/jsx.js

@@ -0,0 +1,22 @@
+var REACT_ELEMENT_TYPE;
+function _createRawReactElement(e, r, E, l) {
+  REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103);
+  var o = e && e.defaultProps,
+    n = arguments.length - 3;
+  if (r || 0 === n || (r = {
+    children: void 0
+  }), 1 === n) r.children = l;else if (n > 1) {
+    for (var t = Array(n), f = 0; f < n; f++) t[f] = arguments[f + 3];
+    r.children = t;
+  }
+  if (r && o) for (var i in o) void 0 === r[i] && (r[i] = o[i]);else r || (r = o || {});
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: e,
+    key: void 0 === E ? null : "" + E,
+    ref: null,
+    props: r,
+    _owner: null
+  };
+}
+module.exports = _createRawReactElement, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/maybeArrayLike.js

@@ -0,0 +1,9 @@
+var arrayLikeToArray = require("./arrayLikeToArray.js");
+function _maybeArrayLike(r, a, e) {
+  if (a && !Array.isArray(a) && "number" == typeof a.length) {
+    var y = a.length;
+    return arrayLikeToArray(a, void 0 !== e && e < y ? e : y);
+  }
+  return r(a, e);
+}
+module.exports = _maybeArrayLike, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/newArrowCheck.js

@@ -0,0 +1,4 @@
+function _newArrowCheck(n, r) {
+  if (n !== r) throw new TypeError("Cannot instantiate an arrow function");
+}
+module.exports = _newArrowCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/nonIterableRest.js

@@ -0,0 +1,4 @@
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/nonIterableSpread.js

@@ -0,0 +1,4 @@
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/nullishReceiverError.js

@@ -0,0 +1,4 @@
+function _nullishReceiverError(r) {
+  throw new TypeError("Cannot set property of null or undefined.");
+}
+module.exports = _nullishReceiverError, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/objectDestructuringEmpty.js

@@ -0,0 +1,4 @@
+function _objectDestructuringEmpty(t) {
+  if (null == t) throw new TypeError("Cannot destructure " + t);
+}
+module.exports = _objectDestructuringEmpty, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/objectSpread.js

@@ -0,0 +1,14 @@
+var defineProperty = require("./defineProperty.js");
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? Object(arguments[r]) : {},
+      o = Object.keys(t);
+    "function" == typeof Object.getOwnPropertySymbols && o.push.apply(o, Object.getOwnPropertySymbols(t).filter(function (e) {
+      return Object.getOwnPropertyDescriptor(t, e).enumerable;
+    })), o.forEach(function (r) {
+      defineProperty(e, r, t[r]);
+    });
+  }
+  return e;
+}
+module.exports = _objectSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/objectSpread2.js

@@ -0,0 +1,23 @@
+var defineProperty = require("./defineProperty.js");
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/objectWithoutProperties.js

@@ -0,0 +1,13 @@
+var objectWithoutPropertiesLoose = require("./objectWithoutPropertiesLoose.js");
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/objectWithoutPropertiesLoose.js

@@ -0,0 +1,10 @@
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/possibleConstructorReturn.js

@@ -0,0 +1,8 @@
+var _typeof = require("./typeof.js")["default"];
+var assertThisInitialized = require("./assertThisInitialized.js");
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return assertThisInitialized(t);
+}
+module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;

package/src/helpers/readOnlyError.js

@@ -0,0 +1,4 @@
+function _readOnlyError(r) {
+  throw new TypeError('"' + r + '" is read-only');
+}
+module.exports = _readOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports;