armtek-uikit-react 1.0.268 → 1.0.270

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

@@ -0,0 +1,42 @@
+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;
+}
+export {
+  arrayFrom as default
+};

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

@@ -0,0 +1,87 @@
+import getRole, { getLocalName } from "./getRole.js";
+function isElement(node) {
+  return node !== null && node.nodeType === node.ELEMENT_NODE;
+}
+function isHTMLTableCaptionElement(node) {
+  return isElement(node) && getLocalName(node) === "caption";
+}
+function isHTMLInputElement(node) {
+  return isElement(node) && getLocalName(node) === "input";
+}
+function isHTMLOptGroupElement(node) {
+  return isElement(node) && getLocalName(node) === "optgroup";
+}
+function isHTMLSelectElement(node) {
+  return isElement(node) && getLocalName(node) === "select";
+}
+function isHTMLTableElement(node) {
+  return isElement(node) && getLocalName(node) === "table";
+}
+function isHTMLTextAreaElement(node) {
+  return isElement(node) && 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) && getLocalName(node) === "fieldset";
+}
+function isHTMLLegendElement(node) {
+  return isElement(node) && getLocalName(node) === "legend";
+}
+function isHTMLSlotElement(node) {
+  return isElement(node) && getLocalName(node) === "slot";
+}
+function isSVGElement(node) {
+  return isElement(node) && node.ownerSVGElement !== void 0;
+}
+function isSVGSVGElement(node) {
+  return isElement(node) && getLocalName(node) === "svg";
+}
+function isSVGTitleElement(node) {
+  return isSVGElement(node) && 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(node)) !== -1;
+  }
+  return false;
+}
+export {
+  getLocalName,
+  hasAnyConcreteRoles,
+  isElement,
+  isHTMLFieldSetElement,
+  isHTMLInputElement,
+  isHTMLLegendElement,
+  isHTMLOptGroupElement,
+  isHTMLSelectElement,
+  isHTMLSlotElement,
+  isHTMLTableCaptionElement,
+  isHTMLTableElement,
+  isHTMLTextAreaElement,
+  isSVGElement,
+  isSVGSVGElement,
+  isSVGTitleElement,
+  queryIdRefs,
+  safeWindow
+};

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

@@ -0,0 +1,268 @@
+var _a;
+import * as React from "react";
+import * as DeprecatedReactTestUtils from "react-dom/test-utils";
+import "react-dom";
+import "react-dom/client";
+import { fireEvent as fireEvent$1, configure } from "../../../dom/dist/@testing-library/dom.esm.js";
+import { buildQueries, createEvent, findAllByAltText, findAllByDisplayValue, findAllByLabelText, findAllByPlaceholderText, findAllByRole, findAllByTestId, findAllByText, findAllByTitle, findByAltText, findByDisplayValue, findByLabelText, findByPlaceholderText, findByRole, findByTestId, findByText, findByTitle, getAllByAltText, getAllByDisplayValue, getAllByLabelText, getAllByPlaceholderText, getAllByRole, getAllByTestId, getAllByText, getAllByTitle, getByAltText, getByDisplayValue, getByLabelText, getByPlaceholderText, getByRole, getByTestId, getByText, getByTitle, getDefaultNormalizer, getElementError, getMultipleElementsFoundError, getNodeText, getQueriesForElement, getRoles, getSuggestedQuery, isInaccessible, logDOM, makeFindQuery, makeGetAllQuery, makeSingleQuery, prettyDOM, queries, queryAllByAltText, queryAllByAttribute, queryAllByDisplayValue, queryAllByLabelText, queryAllByPlaceholderText, queryAllByRole, queryAllByTestId, queryAllByText, queryAllByTitle, queryByAltText, queryByDisplayValue, queryByLabelText, queryByPlaceholderText, queryByRole, queryByTestId, queryByText, queryByTitle, screen, waitFor, getQueriesForElement as getQueriesForElement2, wrapAllByQueryWithSuggestion, wrapSingleQueryWithSuggestion } from "../../../dom/dist/@testing-library/dom.esm.js";
+const reactAct = typeof React.act === "function" ? React.act : DeprecatedReactTestUtils.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 fireEvent$1(...arguments);
+};
+Object.keys(fireEvent$1).forEach((key) => {
+  fireEvent[key] = function() {
+    return fireEvent$1[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;
+}
+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);
+    });
+  }
+}
+export {
+  act,
+  buildQueries,
+  cleanup,
+  createEvent,
+  findAllByAltText,
+  findAllByDisplayValue,
+  findAllByLabelText,
+  findAllByPlaceholderText,
+  findAllByRole,
+  findAllByTestId,
+  findAllByText,
+  findAllByTitle,
+  findByAltText,
+  findByDisplayValue,
+  findByLabelText,
+  findByPlaceholderText,
+  findByRole,
+  findByTestId,
+  findByText,
+  findByTitle,
+  fireEvent,
+  getAllByAltText,
+  getAllByDisplayValue,
+  getAllByLabelText,
+  getAllByPlaceholderText,
+  getAllByRole,
+  getAllByTestId,
+  getAllByText,
+  getAllByTitle,
+  getByAltText,
+  getByDisplayValue,
+  getByLabelText,
+  getByPlaceholderText,
+  getByRole,
+  getByTestId,
+  getByText,
+  getByTitle,
+  getDefaultNormalizer,
+  getElementError,
+  getMultipleElementsFoundError,
+  getNodeText,
+  getQueriesForElement,
+  getRoles,
+  getSuggestedQuery,
+  isInaccessible,
+  logDOM,
+  makeFindQuery,
+  makeGetAllQuery,
+  makeSingleQuery,
+  prettyDOM,
+  queries,
+  queryAllByAltText,
+  queryAllByAttribute,
+  queryAllByDisplayValue,
+  queryAllByLabelText,
+  queryAllByPlaceholderText,
+  queryAllByRole,
+  queryAllByTestId,
+  queryAllByText,
+  queryAllByTitle,
+  queryByAltText,
+  queryByDisplayValue,
+  queryByLabelText,
+  queryByPlaceholderText,
+  queryByRole,
+  queryByTestId,
+  queryByText,
+  queryByTitle,
+  screen,
+  waitFor,
+  getQueriesForElement2 as within,
+  wrapAllByQueryWithSuggestion,
+  wrapSingleQueryWithSuggestion
+};

package/lib/esm/node_modules/ansi-regex/index.js

@@ -0,0 +1,17 @@
+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;
+}
+export {
+  requireAnsiRegex as __require
+};

package/lib/esm/node_modules/array-buffer-byte-length/index.js

@@ -0,0 +1,21 @@
+import { __require as requireCallBound } from "../call-bound/index.js";
+import { __require as requireIsArrayBuffer } from "../is-array-buffer/index.js";
+var arrayBufferByteLength;
+var hasRequiredArrayBufferByteLength;
+function requireArrayBufferByteLength() {
+  if (hasRequiredArrayBufferByteLength) return arrayBufferByteLength;
+  hasRequiredArrayBufferByteLength = 1;
+  var callBound = /* @__PURE__ */ requireCallBound();
+  var $byteLength = callBound("ArrayBuffer.prototype.byteLength", true);
+  var isArrayBuffer = /* @__PURE__ */ requireIsArrayBuffer();
+  arrayBufferByteLength = function byteLength(ab) {
+    if (!isArrayBuffer(ab)) {
+      return NaN;
+    }
+    return $byteLength ? $byteLength(ab) : ab.byteLength;
+  };
+  return arrayBufferByteLength;
+}
+export {
+  requireArrayBufferByteLength as __require
+};

package/lib/esm/node_modules/available-typed-arrays/index.js

@@ -0,0 +1,23 @@
+import { commonjsGlobal } from "../../_virtual/_commonjsHelpers.js";
+import { __require as requirePossibleTypedArrayNames } from "../possible-typed-array-names/index.js";
+var availableTypedArrays;
+var hasRequiredAvailableTypedArrays;
+function requireAvailableTypedArrays() {
+  if (hasRequiredAvailableTypedArrays) return availableTypedArrays;
+  hasRequiredAvailableTypedArrays = 1;
+  var possibleNames = /* @__PURE__ */ requirePossibleTypedArrayNames();
+  var g = typeof globalThis === "undefined" ? 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;
+}
+export {
+  requireAvailableTypedArrays as __require
+};

package/lib/esm/node_modules/call-bind/callBound.js

@@ -0,0 +1,22 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireCallBind } from "./index.js";
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBind = requireCallBind();
+  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;
+}
+export {
+  requireCallBound as __require
+};

package/lib/esm/node_modules/call-bind/index.js

@@ -0,0 +1,34 @@
+import { __module as callBind } from "../../_virtual/index8.js";
+import { __require as requireSetFunctionLength } from "../set-function-length/index.js";
+import { __require as requireEsDefineProperty } from "../es-define-property/index.js";
+import { __require as requireCallBindApplyHelpers } from "../call-bind-apply-helpers/index.js";
+import { __require as requireApplyBind } from "../call-bind-apply-helpers/applyBind.js";
+var hasRequiredCallBind;
+function requireCallBind() {
+  if (hasRequiredCallBind) return callBind.exports;
+  hasRequiredCallBind = 1;
+  (function(module) {
+    var setFunctionLength = /* @__PURE__ */ requireSetFunctionLength();
+    var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
+    var callBindBasic = requireCallBindApplyHelpers();
+    var applyBind = requireApplyBind();
+    module.exports = function callBind2(originalFunction) {
+      var func = callBindBasic(arguments);
+      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      return setFunctionLength(
+        func,
+        1 + (adjustedLength > 0 ? adjustedLength : 0),
+        true
+      );
+    };
+    if ($defineProperty) {
+      $defineProperty(module.exports, "apply", { value: applyBind });
+    } else {
+      module.exports.apply = applyBind;
+    }
+  })(callBind);
+  return callBind.exports;
+}
+export {
+  requireCallBind as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/actualApply.js

@@ -0,0 +1,19 @@
+import { __require as requireFunctionBind } from "../function-bind/index.js";
+import { __require as requireFunctionApply } from "./functionApply.js";
+import { __require as requireFunctionCall } from "./functionCall.js";
+import { __require as requireReflectApply } from "./reflectApply.js";
+var actualApply;
+var hasRequiredActualApply;
+function requireActualApply() {
+  if (hasRequiredActualApply) return actualApply;
+  hasRequiredActualApply = 1;
+  var bind = requireFunctionBind();
+  var $apply = requireFunctionApply();
+  var $call = requireFunctionCall();
+  var $reflectApply = requireReflectApply();
+  actualApply = $reflectApply || bind.call($call, $apply);
+  return actualApply;
+}
+export {
+  requireActualApply as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/applyBind.js

@@ -0,0 +1,19 @@
+import { __require as requireFunctionBind } from "../function-bind/index.js";
+import { __require as requireFunctionApply } from "./functionApply.js";
+import { __require as requireActualApply } from "./actualApply.js";
+var applyBind;
+var hasRequiredApplyBind;
+function requireApplyBind() {
+  if (hasRequiredApplyBind) return applyBind;
+  hasRequiredApplyBind = 1;
+  var bind = requireFunctionBind();
+  var $apply = requireFunctionApply();
+  var actualApply = requireActualApply();
+  applyBind = function applyBind2() {
+    return actualApply(bind, $apply, arguments);
+  };
+  return applyBind;
+}
+export {
+  requireApplyBind as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/functionApply.js

@@ -0,0 +1,11 @@
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
+export {
+  requireFunctionApply as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/functionCall.js

@@ -0,0 +1,11 @@
+var functionCall;
+var hasRequiredFunctionCall;
+function requireFunctionCall() {
+  if (hasRequiredFunctionCall) return functionCall;
+  hasRequiredFunctionCall = 1;
+  functionCall = Function.prototype.call;
+  return functionCall;
+}
+export {
+  requireFunctionCall as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/index.js

@@ -0,0 +1,24 @@
+import { __require as requireFunctionBind } from "../function-bind/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireFunctionCall } from "./functionCall.js";
+import { __require as requireActualApply } from "./actualApply.js";
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+function requireCallBindApplyHelpers() {
+  if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+  hasRequiredCallBindApplyHelpers = 1;
+  var bind = requireFunctionBind();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $call = requireFunctionCall();
+  var $actualApply = requireActualApply();
+  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;
+}
+export {
+  requireCallBindApplyHelpers as __require
+};

package/lib/esm/node_modules/call-bind-apply-helpers/reflectApply.js

@@ -0,0 +1,11 @@
+var reflectApply;
+var hasRequiredReflectApply;
+function requireReflectApply() {
+  if (hasRequiredReflectApply) return reflectApply;
+  hasRequiredReflectApply = 1;
+  reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  return reflectApply;
+}
+export {
+  requireReflectApply as __require
+};

package/lib/esm/node_modules/call-bound/index.js

@@ -0,0 +1,28 @@
+import { __require as requireGetIntrinsic } from "../get-intrinsic/index.js";
+import { __require as requireCallBindApplyHelpers } from "../call-bind-apply-helpers/index.js";
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBindBasic = requireCallBindApplyHelpers();
+  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;
+}
+export {
+  requireCallBound as __require
+};