armtek-uikit-react 1.0.268 → 1.0.270

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/polyfills/array.from.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var toStr = Object.prototype.toString;
+function isCallable(fn) {
+  return typeof fn === "function" || toStr.call(fn) === "[object Function]";
+}
+function toInteger(value) {
+  var number = Number(value);
+  if (isNaN(number)) {
+    return 0;
+  }
+  if (number === 0 || !isFinite(number)) {
+    return number;
+  }
+  return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+}
+var maxSafeInteger = Math.pow(2, 53) - 1;
+function toLength(value) {
+  var len = toInteger(value);
+  return Math.min(Math.max(len, 0), maxSafeInteger);
+}
+function arrayFrom(arrayLike, mapFn) {
+  var C = Array;
+  var items = Object(arrayLike);
+  if (arrayLike == null) {
+    throw new TypeError("Array.from requires an array-like object - not null or undefined");
+  }
+  var len = toLength(items.length);
+  var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+  var k = 0;
+  var kValue;
+  while (k < len) {
+    kValue = items[k];
+    {
+      A[k] = kValue;
+    }
+    k += 1;
+  }
+  A.length = len;
+  return A;
+}
+exports.default = arrayFrom;

package/lib/cjs/node_modules/@testing-library/dom/node_modules/dom-accessibility-api/dist/util.cjs

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getRole = require("./getRole.cjs");
+function isElement(node) {
+  return node !== null && node.nodeType === node.ELEMENT_NODE;
+}
+function isHTMLTableCaptionElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "caption";
+}
+function isHTMLInputElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "input";
+}
+function isHTMLOptGroupElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "optgroup";
+}
+function isHTMLSelectElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "select";
+}
+function isHTMLTableElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "table";
+}
+function isHTMLTextAreaElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "textarea";
+}
+function safeWindow(node) {
+  var _ref = node.ownerDocument === null ? node : node.ownerDocument, defaultView = _ref.defaultView;
+  if (defaultView === null) {
+    throw new TypeError("no window available");
+  }
+  return defaultView;
+}
+function isHTMLFieldSetElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "fieldset";
+}
+function isHTMLLegendElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "legend";
+}
+function isHTMLSlotElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "slot";
+}
+function isSVGElement(node) {
+  return isElement(node) && node.ownerSVGElement !== void 0;
+}
+function isSVGSVGElement(node) {
+  return isElement(node) && getRole.getLocalName(node) === "svg";
+}
+function isSVGTitleElement(node) {
+  return isSVGElement(node) && getRole.getLocalName(node) === "title";
+}
+function queryIdRefs(node, attributeName) {
+  if (isElement(node) && node.hasAttribute(attributeName)) {
+    var ids = node.getAttribute(attributeName).split(" ");
+    var root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
+    return ids.map(function(id) {
+      return root.getElementById(id);
+    }).filter(
+      function(element) {
+        return element !== null;
+      }
+      // TODO: why does this not narrow?
+    );
+  }
+  return [];
+}
+function hasAnyConcreteRoles(node, roles) {
+  if (isElement(node)) {
+    return roles.indexOf(getRole.default(node)) !== -1;
+  }
+  return false;
+}
+exports.getLocalName = getRole.getLocalName;
+exports.hasAnyConcreteRoles = hasAnyConcreteRoles;
+exports.isElement = isElement;
+exports.isHTMLFieldSetElement = isHTMLFieldSetElement;
+exports.isHTMLInputElement = isHTMLInputElement;
+exports.isHTMLLegendElement = isHTMLLegendElement;
+exports.isHTMLOptGroupElement = isHTMLOptGroupElement;
+exports.isHTMLSelectElement = isHTMLSelectElement;
+exports.isHTMLSlotElement = isHTMLSlotElement;
+exports.isHTMLTableCaptionElement = isHTMLTableCaptionElement;
+exports.isHTMLTableElement = isHTMLTableElement;
+exports.isHTMLTextAreaElement = isHTMLTextAreaElement;
+exports.isSVGElement = isSVGElement;
+exports.isSVGSVGElement = isSVGSVGElement;
+exports.isSVGTitleElement = isSVGTitleElement;
+exports.queryIdRefs = queryIdRefs;
+exports.safeWindow = safeWindow;

package/lib/cjs/node_modules/@testing-library/react/dist/@testing-library/react.esm.cjs

@@ -0,0 +1,285 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const DeprecatedReactTestUtils = require("react-dom/test-utils");
+require("react-dom");
+require("react-dom/client");
+const dom_esm = require("../../../dom/dist/@testing-library/dom.esm.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+const DeprecatedReactTestUtils__namespace = /* @__PURE__ */ _interopNamespaceDefault(DeprecatedReactTestUtils);
+const reactAct = typeof React__namespace.act === "function" ? React__namespace.act : DeprecatedReactTestUtils__namespace.act;
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("unable to locate global object");
+}
+function setIsReactActEnvironment(isReactActEnvironment) {
+  getGlobalThis().IS_REACT_ACT_ENVIRONMENT = isReactActEnvironment;
+}
+function getIsReactActEnvironment() {
+  return getGlobalThis().IS_REACT_ACT_ENVIRONMENT;
+}
+function withGlobalActEnvironment(actImplementation) {
+  return (callback) => {
+    const previousActEnvironment = getIsReactActEnvironment();
+    setIsReactActEnvironment(true);
+    try {
+      let callbackNeedsToBeAwaited = false;
+      const actResult = actImplementation(() => {
+        const result = callback();
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          callbackNeedsToBeAwaited = true;
+        }
+        return result;
+      });
+      if (callbackNeedsToBeAwaited) {
+        const thenable = actResult;
+        return {
+          then: (resolve, reject) => {
+            thenable.then((returnValue) => {
+              setIsReactActEnvironment(previousActEnvironment);
+              resolve(returnValue);
+            }, (error) => {
+              setIsReactActEnvironment(previousActEnvironment);
+              reject(error);
+            });
+          }
+        };
+      } else {
+        setIsReactActEnvironment(previousActEnvironment);
+        return actResult;
+      }
+    } catch (error) {
+      setIsReactActEnvironment(previousActEnvironment);
+      throw error;
+    }
+  };
+}
+const act = withGlobalActEnvironment(reactAct);
+const fireEvent = function() {
+  return dom_esm.fireEvent(...arguments);
+};
+Object.keys(dom_esm.fireEvent).forEach((key) => {
+  fireEvent[key] = function() {
+    return dom_esm.fireEvent[key](...arguments);
+  };
+});
+const mouseEnter = fireEvent.mouseEnter;
+const mouseLeave = fireEvent.mouseLeave;
+fireEvent.mouseEnter = function() {
+  mouseEnter(...arguments);
+  return fireEvent.mouseOver(...arguments);
+};
+fireEvent.mouseLeave = function() {
+  mouseLeave(...arguments);
+  return fireEvent.mouseOut(...arguments);
+};
+const pointerEnter = fireEvent.pointerEnter;
+const pointerLeave = fireEvent.pointerLeave;
+fireEvent.pointerEnter = function() {
+  pointerEnter(...arguments);
+  return fireEvent.pointerOver(...arguments);
+};
+fireEvent.pointerLeave = function() {
+  pointerLeave(...arguments);
+  return fireEvent.pointerOut(...arguments);
+};
+const select = fireEvent.select;
+fireEvent.select = (node, init) => {
+  select(node, init);
+  node.focus();
+  fireEvent.keyUp(node, init);
+};
+const blur = fireEvent.blur;
+const focus = fireEvent.focus;
+fireEvent.blur = function() {
+  fireEvent.focusOut(...arguments);
+  return blur(...arguments);
+};
+fireEvent.focus = function() {
+  fireEvent.focusIn(...arguments);
+  return focus(...arguments);
+};
+function jestFakeTimersAreEnabled() {
+  if (typeof jest !== "undefined" && jest !== null) {
+    return (
+      // legacy timers
+      setTimeout._isMockFunction === true || // modern timers
+      // eslint-disable-next-line prefer-object-has-own -- No Object.hasOwn in all target environments we support.
+      Object.prototype.hasOwnProperty.call(setTimeout, "clock")
+    );
+  }
+  return false;
+}
+dom_esm.configure({
+  unstable_advanceTimersWrapper: (cb) => {
+    return act(cb);
+  },
+  // We just want to run `waitFor` without IS_REACT_ACT_ENVIRONMENT
+  // But that's not necessarily how `asyncWrapper` is used since it's a public method.
+  // Let's just hope nobody else is using it.
+  asyncWrapper: async (cb) => {
+    const previousActEnvironment = getIsReactActEnvironment();
+    setIsReactActEnvironment(false);
+    try {
+      const result = await cb();
+      await new Promise((resolve) => {
+        setTimeout(() => {
+          resolve();
+        }, 0);
+        if (jestFakeTimersAreEnabled()) {
+          jest.advanceTimersByTime(0);
+        }
+      });
+      return result;
+    } finally {
+      setIsReactActEnvironment(previousActEnvironment);
+    }
+  },
+  eventWrapper: (cb) => {
+    let result;
+    act(() => {
+      result = cb();
+    });
+    return result;
+  }
+});
+const mountedContainers = /* @__PURE__ */ new Set();
+const mountedRootEntries = [];
+function cleanup() {
+  mountedRootEntries.forEach((_ref3) => {
+    let {
+      root,
+      container
+    } = _ref3;
+    act(() => {
+      root.unmount();
+    });
+    if (container.parentNode === document.body) {
+      document.body.removeChild(container);
+    }
+  });
+  mountedRootEntries.length = 0;
+  mountedContainers.clear();
+}
+if (typeof process === "undefined" || !((_a = process.env) == null ? void 0 : _a.RTL_SKIP_AUTO_CLEANUP)) {
+  if (typeof afterEach === "function") {
+    afterEach(() => {
+      cleanup();
+    });
+  } else if (typeof teardown === "function") {
+    teardown(() => {
+      cleanup();
+    });
+  }
+  if (typeof beforeAll === "function" && typeof afterAll === "function") {
+    let previousIsReactActEnvironment = getIsReactActEnvironment();
+    beforeAll(() => {
+      previousIsReactActEnvironment = getIsReactActEnvironment();
+      setIsReactActEnvironment(true);
+    });
+    afterAll(() => {
+      setIsReactActEnvironment(previousIsReactActEnvironment);
+    });
+  }
+}
+exports.buildQueries = dom_esm.buildQueries;
+exports.createEvent = dom_esm.createEvent;
+exports.findAllByAltText = dom_esm.findAllByAltText;
+exports.findAllByDisplayValue = dom_esm.findAllByDisplayValue;
+exports.findAllByLabelText = dom_esm.findAllByLabelText;
+exports.findAllByPlaceholderText = dom_esm.findAllByPlaceholderText;
+exports.findAllByRole = dom_esm.findAllByRole;
+exports.findAllByTestId = dom_esm.findAllByTestId;
+exports.findAllByText = dom_esm.findAllByText;
+exports.findAllByTitle = dom_esm.findAllByTitle;
+exports.findByAltText = dom_esm.findByAltText;
+exports.findByDisplayValue = dom_esm.findByDisplayValue;
+exports.findByLabelText = dom_esm.findByLabelText;
+exports.findByPlaceholderText = dom_esm.findByPlaceholderText;
+exports.findByRole = dom_esm.findByRole;
+exports.findByTestId = dom_esm.findByTestId;
+exports.findByText = dom_esm.findByText;
+exports.findByTitle = dom_esm.findByTitle;
+exports.getAllByAltText = dom_esm.getAllByAltText;
+exports.getAllByDisplayValue = dom_esm.getAllByDisplayValue;
+exports.getAllByLabelText = dom_esm.getAllByLabelText;
+exports.getAllByPlaceholderText = dom_esm.getAllByPlaceholderText;
+exports.getAllByRole = dom_esm.getAllByRole;
+exports.getAllByTestId = dom_esm.getAllByTestId;
+exports.getAllByText = dom_esm.getAllByText;
+exports.getAllByTitle = dom_esm.getAllByTitle;
+exports.getByAltText = dom_esm.getByAltText;
+exports.getByDisplayValue = dom_esm.getByDisplayValue;
+exports.getByLabelText = dom_esm.getByLabelText;
+exports.getByPlaceholderText = dom_esm.getByPlaceholderText;
+exports.getByRole = dom_esm.getByRole;
+exports.getByTestId = dom_esm.getByTestId;
+exports.getByText = dom_esm.getByText;
+exports.getByTitle = dom_esm.getByTitle;
+exports.getDefaultNormalizer = dom_esm.getDefaultNormalizer;
+exports.getElementError = dom_esm.getElementError;
+exports.getMultipleElementsFoundError = dom_esm.getMultipleElementsFoundError;
+exports.getNodeText = dom_esm.getNodeText;
+exports.getQueriesForElement = dom_esm.getQueriesForElement;
+exports.getRoles = dom_esm.getRoles;
+exports.getSuggestedQuery = dom_esm.getSuggestedQuery;
+exports.isInaccessible = dom_esm.isInaccessible;
+exports.logDOM = dom_esm.logDOM;
+exports.makeFindQuery = dom_esm.makeFindQuery;
+exports.makeGetAllQuery = dom_esm.makeGetAllQuery;
+exports.makeSingleQuery = dom_esm.makeSingleQuery;
+exports.prettyDOM = dom_esm.prettyDOM;
+exports.queries = dom_esm.queries;
+exports.queryAllByAltText = dom_esm.queryAllByAltText;
+exports.queryAllByAttribute = dom_esm.queryAllByAttribute;
+exports.queryAllByDisplayValue = dom_esm.queryAllByDisplayValue;
+exports.queryAllByLabelText = dom_esm.queryAllByLabelText;
+exports.queryAllByPlaceholderText = dom_esm.queryAllByPlaceholderText;
+exports.queryAllByRole = dom_esm.queryAllByRole;
+exports.queryAllByTestId = dom_esm.queryAllByTestId;
+exports.queryAllByText = dom_esm.queryAllByText;
+exports.queryAllByTitle = dom_esm.queryAllByTitle;
+exports.queryByAltText = dom_esm.queryByAltText;
+exports.queryByDisplayValue = dom_esm.queryByDisplayValue;
+exports.queryByLabelText = dom_esm.queryByLabelText;
+exports.queryByPlaceholderText = dom_esm.queryByPlaceholderText;
+exports.queryByRole = dom_esm.queryByRole;
+exports.queryByTestId = dom_esm.queryByTestId;
+exports.queryByText = dom_esm.queryByText;
+exports.queryByTitle = dom_esm.queryByTitle;
+exports.screen = dom_esm.screen;
+exports.waitFor = dom_esm.waitFor;
+exports.within = dom_esm.getQueriesForElement;
+exports.wrapAllByQueryWithSuggestion = dom_esm.wrapAllByQueryWithSuggestion;
+exports.wrapSingleQueryWithSuggestion = dom_esm.wrapSingleQueryWithSuggestion;
+exports.act = act;
+exports.cleanup = cleanup;
+exports.fireEvent = fireEvent;

package/lib/cjs/node_modules/ansi-regex/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var ansiRegex;
+var hasRequiredAnsiRegex;
+function requireAnsiRegex() {
+  if (hasRequiredAnsiRegex) return ansiRegex;
+  hasRequiredAnsiRegex = 1;
+  ansiRegex = ({ onlyFirst = false } = {}) => {
+    const pattern = [
+      "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+      "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+    ].join("|");
+    return new RegExp(pattern, onlyFirst ? void 0 : "g");
+  };
+  return ansiRegex;
+}
+exports.__require = requireAnsiRegex;

package/lib/cjs/node_modules/array-buffer-byte-length/index.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../call-bound/index.cjs");
+const index$1 = require("../is-array-buffer/index.cjs");
+var arrayBufferByteLength;
+var hasRequiredArrayBufferByteLength;
+function requireArrayBufferByteLength() {
+  if (hasRequiredArrayBufferByteLength) return arrayBufferByteLength;
+  hasRequiredArrayBufferByteLength = 1;
+  var callBound = /* @__PURE__ */ index.__require();
+  var $byteLength = callBound("ArrayBuffer.prototype.byteLength", true);
+  var isArrayBuffer = /* @__PURE__ */ index$1.__require();
+  arrayBufferByteLength = function byteLength(ab) {
+    if (!isArrayBuffer(ab)) {
+      return NaN;
+    }
+    return $byteLength ? $byteLength(ab) : ab.byteLength;
+  };
+  return arrayBufferByteLength;
+}
+exports.__require = requireArrayBufferByteLength;

package/lib/cjs/node_modules/available-typed-arrays/index.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _commonjsHelpers = require("../../_virtual/_commonjsHelpers.cjs");
+const index = require("../possible-typed-array-names/index.cjs");
+var availableTypedArrays;
+var hasRequiredAvailableTypedArrays;
+function requireAvailableTypedArrays() {
+  if (hasRequiredAvailableTypedArrays) return availableTypedArrays;
+  hasRequiredAvailableTypedArrays = 1;
+  var possibleNames = /* @__PURE__ */ index.__require();
+  var g = typeof globalThis === "undefined" ? _commonjsHelpers.commonjsGlobal : globalThis;
+  availableTypedArrays = function availableTypedArrays2() {
+    var out = [];
+    for (var i = 0; i < possibleNames.length; i++) {
+      if (typeof g[possibleNames[i]] === "function") {
+        out[out.length] = possibleNames[i];
+      }
+    }
+    return out;
+  };
+  return availableTypedArrays;
+}
+exports.__require = requireAvailableTypedArrays;

package/lib/cjs/node_modules/call-bind/callBound.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../get-intrinsic/index.cjs");
+const index = require("./index.cjs");
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ index$1.__require();
+  var callBind = index.__require();
+  var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    var intrinsic = GetIntrinsic(name, !!allowMissing);
+    if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+      return callBind(intrinsic);
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
+exports.__require = requireCallBound;

package/lib/cjs/node_modules/call-bind/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../_virtual/index8.cjs");
+const index$2 = require("../set-function-length/index.cjs");
+const index$3 = require("../es-define-property/index.cjs");
+const index$1 = require("../call-bind-apply-helpers/index.cjs");
+const applyBind = require("../call-bind-apply-helpers/applyBind.cjs");
+var hasRequiredCallBind;
+function requireCallBind() {
+  if (hasRequiredCallBind) return index.__module.exports;
+  hasRequiredCallBind = 1;
+  (function(module2) {
+    var setFunctionLength = /* @__PURE__ */ index$2.__require();
+    var $defineProperty = /* @__PURE__ */ index$3.__require();
+    var callBindBasic = index$1.__require();
+    var applyBind$1 = applyBind.__require();
+    module2.exports = function callBind(originalFunction) {
+      var func = callBindBasic(arguments);
+      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      return setFunctionLength(
+        func,
+        1 + (adjustedLength > 0 ? adjustedLength : 0),
+        true
+      );
+    };
+    if ($defineProperty) {
+      $defineProperty(module2.exports, "apply", { value: applyBind$1 });
+    } else {
+      module2.exports.apply = applyBind$1;
+    }
+  })(index.__module);
+  return index.__module.exports;
+}
+exports.__require = requireCallBind;

package/lib/cjs/node_modules/call-bind-apply-helpers/actualApply.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../function-bind/index.cjs");
+const functionApply = require("./functionApply.cjs");
+const functionCall = require("./functionCall.cjs");
+const reflectApply = require("./reflectApply.cjs");
+var actualApply;
+var hasRequiredActualApply;
+function requireActualApply() {
+  if (hasRequiredActualApply) return actualApply;
+  hasRequiredActualApply = 1;
+  var bind = index.__require();
+  var $apply = functionApply.__require();
+  var $call = functionCall.__require();
+  var $reflectApply = reflectApply.__require();
+  actualApply = $reflectApply || bind.call($call, $apply);
+  return actualApply;
+}
+exports.__require = requireActualApply;

package/lib/cjs/node_modules/call-bind-apply-helpers/applyBind.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../function-bind/index.cjs");
+const functionApply = require("./functionApply.cjs");
+const actualApply = require("./actualApply.cjs");
+var applyBind;
+var hasRequiredApplyBind;
+function requireApplyBind() {
+  if (hasRequiredApplyBind) return applyBind;
+  hasRequiredApplyBind = 1;
+  var bind = index.__require();
+  var $apply = functionApply.__require();
+  var actualApply$1 = actualApply.__require();
+  applyBind = function applyBind2() {
+    return actualApply$1(bind, $apply, arguments);
+  };
+  return applyBind;
+}
+exports.__require = requireApplyBind;

package/lib/cjs/node_modules/call-bind-apply-helpers/functionApply.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
+exports.__require = requireFunctionApply;

package/lib/cjs/node_modules/call-bind-apply-helpers/functionCall.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var functionCall;
+var hasRequiredFunctionCall;
+function requireFunctionCall() {
+  if (hasRequiredFunctionCall) return functionCall;
+  hasRequiredFunctionCall = 1;
+  functionCall = Function.prototype.call;
+  return functionCall;
+}
+exports.__require = requireFunctionCall;

package/lib/cjs/node_modules/call-bind-apply-helpers/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../function-bind/index.cjs");
+const type = require("../es-errors/type.cjs");
+const functionCall = require("./functionCall.cjs");
+const actualApply = require("./actualApply.cjs");
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+function requireCallBindApplyHelpers() {
+  if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+  hasRequiredCallBindApplyHelpers = 1;
+  var bind = index.__require();
+  var $TypeError = /* @__PURE__ */ type.__require();
+  var $call = functionCall.__require();
+  var $actualApply = actualApply.__require();
+  callBindApplyHelpers = function callBindBasic(args) {
+    if (args.length < 1 || typeof args[0] !== "function") {
+      throw new $TypeError("a function is required");
+    }
+    return $actualApply(bind, $call, args);
+  };
+  return callBindApplyHelpers;
+}
+exports.__require = requireCallBindApplyHelpers;

package/lib/cjs/node_modules/call-bind-apply-helpers/reflectApply.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var reflectApply;
+var hasRequiredReflectApply;
+function requireReflectApply() {
+  if (hasRequiredReflectApply) return reflectApply;
+  hasRequiredReflectApply = 1;
+  reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  return reflectApply;
+}
+exports.__require = requireReflectApply;

package/lib/cjs/node_modules/call-bound/index.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../get-intrinsic/index.cjs");
+const index = require("../call-bind-apply-helpers/index.cjs");
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ index$1.__require();
+  var callBindBasic = index.__require();
+  var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    var intrinsic = (
+      /** @type {(this: unknown, ...args: unknown[]) => unknown} */
+      GetIntrinsic(name, !!allowMissing)
+    );
+    if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+      return callBindBasic(
+        /** @type {const} */
+        [intrinsic]
+      );
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
+exports.__require = requireCallBound;