impact-ui 5.0.0 → 5.0.1-beta.1

package/dist/node_modules/@mui/icons-material/utils/createSvgIcon.js

@@ -4,12 +4,12 @@ var hasRequiredCreateSvgIcon;
 function requireCreateSvgIcon() {
   if (hasRequiredCreateSvgIcon) return createSvgIcon;
   hasRequiredCreateSvgIcon = 1;
-  (function(exports$1) {
+  (function(exports) {
     "use client";
-    Object.defineProperty(exports$1, "__esModule", {
+    Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    Object.defineProperty(exports$1, "default", {
+    Object.defineProperty(exports, "default", {
       enumerable: true,
       get: function() {
         return _utils.createSvgIcon;

package/dist/node_modules/@mui/material/styles/ThemeProvider.js

@@ -0,0 +1,43 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import "react";
+import PropTypes from "../../../prop-types/index.js";
+import THEME_ID from "./identifier.js";
+import { jsx } from "react/jsx-runtime";
+import ThemeProvider$1 from "../../system/esm/ThemeProvider/ThemeProvider.js";
+const _excluded = ["theme"];
+function ThemeProvider(_ref) {
+  let {
+    theme: themeInput
+  } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const scopedTheme = themeInput[THEME_ID];
+  let finalTheme = scopedTheme || themeInput;
+  if (typeof themeInput !== "function") {
+    if (scopedTheme && !scopedTheme.vars) {
+      finalTheme = _extends({}, scopedTheme, {
+        vars: null
+      });
+    } else if (themeInput && !themeInput.vars) {
+      finalTheme = _extends({}, themeInput, {
+        vars: null
+      });
+    }
+  }
+  return /* @__PURE__ */ jsx(ThemeProvider$1, _extends({}, props, {
+    themeId: scopedTheme ? THEME_ID : void 0,
+    theme: finalTheme
+  }));
+}
+process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = {
+  /**
+   * Your component tree.
+   */
+  children: PropTypes.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
+} : void 0;
+export {
+  ThemeProvider as default
+};

package/dist/node_modules/@mui/private-theming/ThemeProvider/ThemeProvider.js

@@ -0,0 +1,59 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from "react";
+import PropTypes from "../../../prop-types/index.js";
+import ThemeContext from "../useTheme/ThemeContext.js";
+import nested from "./nested.js";
+import { jsx } from "react/jsx-runtime";
+import useTheme from "../useTheme/useTheme.js";
+import exactProp from "../node_modules/@mui/utils/esm/exactProp/exactProp.js";
+function mergeOuterLocalTheme(outerTheme, localTheme) {
+  if (typeof localTheme === "function") {
+    const mergedTheme = localTheme(outerTheme);
+    if (process.env.NODE_ENV !== "production") {
+      if (!mergedTheme) {
+        console.error(["MUI: You should return an object from your theme function, i.e.", "<ThemeProvider theme={() => ({})} />"].join("\n"));
+      }
+    }
+    return mergedTheme;
+  }
+  return _extends({}, outerTheme, localTheme);
+}
+function ThemeProvider(props) {
+  const {
+    children,
+    theme: localTheme
+  } = props;
+  const outerTheme = useTheme();
+  if (process.env.NODE_ENV !== "production") {
+    if (outerTheme === null && typeof localTheme === "function") {
+      console.error(["MUI: You are providing a theme function prop to the ThemeProvider component:", "<ThemeProvider theme={outerTheme => outerTheme} />", "", "However, no outer theme is present.", "Make sure a theme is already injected higher in the React tree or provide a theme object."].join("\n"));
+    }
+  }
+  const theme = React.useMemo(() => {
+    const output = outerTheme === null ? localTheme : mergeOuterLocalTheme(outerTheme, localTheme);
+    if (output != null) {
+      output[nested] = outerTheme !== null;
+    }
+    return output;
+  }, [localTheme, outerTheme]);
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, {
+    value: theme,
+    children
+  });
+}
+process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = {
+  /**
+   * Your component tree.
+   */
+  children: PropTypes.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
+} : void 0;
+if (process.env.NODE_ENV !== "production") {
+  process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = exactProp(ThemeProvider.propTypes) : void 0;
+}
+export {
+  ThemeProvider as default
+};

package/dist/node_modules/@mui/private-theming/ThemeProvider/nested.js

@@ -0,0 +1,5 @@
+const hasSymbol = typeof Symbol === "function" && Symbol.for;
+const nested = hasSymbol ? Symbol.for("mui.nested") : "__THEME_NESTED__";
+export {
+  nested as default
+};

package/dist/node_modules/@mui/private-theming/node_modules/@mui/utils/esm/exactProp/exactProp.js

@@ -0,0 +1,19 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+const specialProperty = "exact-prop: ​";
+function exactProp(propTypes) {
+  if (process.env.NODE_ENV === "production") {
+    return propTypes;
+  }
+  return _extends({}, propTypes, {
+    [specialProperty]: (props) => {
+      const unsupportedProps = Object.keys(props).filter((prop) => !propTypes.hasOwnProperty(prop));
+      if (unsupportedProps.length > 0) {
+        return new Error(`The following props are not supported: ${unsupportedProps.map((prop) => `\`${prop}\``).join(", ")}. Please remove them.`);
+      }
+      return null;
+    }
+  });
+}
+export {
+  exactProp as default
+};

package/dist/node_modules/@mui/private-theming/useTheme/ThemeContext.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const ThemeContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+  ThemeContext.displayName = "ThemeContext";
+}
+export {
+  ThemeContext as default
+};

package/dist/node_modules/@mui/private-theming/useTheme/useTheme.js

@@ -0,0 +1,12 @@
+import * as React from "react";
+import ThemeContext from "./ThemeContext.js";
+function useTheme() {
+  const theme = React.useContext(ThemeContext);
+  if (process.env.NODE_ENV !== "production") {
+    React.useDebugValue(theme);
+  }
+  return theme;
+}
+export {
+  useTheme as default
+};

package/dist/node_modules/@mui/system/colorManipulator.js

@@ -1,7 +1,7 @@
 import { __exports as colorManipulator } from "../../../_virtual/colorManipulator.js";
 import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
-import require$$1 from "../../../_virtual/index4.js";
-import require$$2 from "../../../_virtual/index5.js";
+import require$$1 from "../../../_virtual/index3.js";
+import require$$2 from "../../../_virtual/index4.js";
 var _interopRequireDefault = require$$0;
 Object.defineProperty(colorManipulator, "__esModule", {
   value: true

package/dist/node_modules/@mui/system/esm/DefaultPropsProvider/DefaultPropsProvider.js

@@ -1,9 +1,18 @@
 import * as React from "react";
 import PropTypes from "../../../../prop-types/index.js";
-import "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import resolveProps from "../../node_modules/@mui/utils/esm/resolveProps/resolveProps.js";
 const PropsContext = /* @__PURE__ */ React.createContext(void 0);
-process.env.NODE_ENV !== "production" ? {
+function DefaultPropsProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsx(PropsContext.Provider, {
+    value,
+    children
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultPropsProvider.propTypes = {
   // ┌────────────────────────────── Warning ──────────────────────────────┐
   // │ These PropTypes are generated from the TypeScript type definitions. │
   // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
@@ -49,5 +58,6 @@ function useDefaultProps({
   });
 }
 export {
+  DefaultPropsProvider as default,
   useDefaultProps
 };

package/dist/node_modules/@mui/system/esm/RtlProvider/index.js

@@ -1,10 +1,19 @@
-import "@babel/runtime/helpers/esm/extends";
-import "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import * as React from "react";
 import PropTypes from "../../../../prop-types/index.js";
-import "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
+const _excluded = ["value"];
 const RtlContext = /* @__PURE__ */ React.createContext();
-process.env.NODE_ENV !== "production" ? {
+function RtlProvider(_ref) {
+  let {
+    value
+  } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  return /* @__PURE__ */ jsx(RtlContext.Provider, _extends({
+    value: value != null ? value : true
+  }, props));
+}
+process.env.NODE_ENV !== "production" ? RtlProvider.propTypes = {
   children: PropTypes.node,
   value: PropTypes.bool
 } : void 0;
@@ -13,5 +22,6 @@ const useRtl = () => {
   return value != null ? value : false;
 };
 export {
+  RtlProvider as default,
   useRtl
 };

package/dist/node_modules/@mui/system/esm/ThemeProvider/ThemeProvider.js

@@ -0,0 +1,86 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from "react";
+import PropTypes from "../../../../prop-types/index.js";
+import useTheme from "../useThemeWithoutDefault.js";
+import RtlProvider from "../RtlProvider/index.js";
+import useLayerOrder from "./useLayerOrder.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import useTheme$1 from "../../../private-theming/useTheme/useTheme.js";
+import ThemeProvider$1 from "../../../private-theming/ThemeProvider/ThemeProvider.js";
+import { T as ThemeContext } from "../../../../@emotion/react/dist/emotion-element-f0de968e.browser.esm.js";
+import DefaultPropsProvider from "../DefaultPropsProvider/DefaultPropsProvider.js";
+import exactProp from "../../node_modules/@mui/utils/esm/exactProp/exactProp.js";
+const EMPTY_THEME = {};
+function useThemeScoping(themeId, upperTheme, localTheme, isPrivate = false) {
+  return React.useMemo(() => {
+    const resolvedTheme = themeId ? upperTheme[themeId] || upperTheme : upperTheme;
+    if (typeof localTheme === "function") {
+      const mergedTheme = localTheme(resolvedTheme);
+      const result = themeId ? _extends({}, upperTheme, {
+        [themeId]: mergedTheme
+      }) : mergedTheme;
+      if (isPrivate) {
+        return () => result;
+      }
+      return result;
+    }
+    return themeId ? _extends({}, upperTheme, {
+      [themeId]: localTheme
+    }) : _extends({}, upperTheme, localTheme);
+  }, [themeId, upperTheme, localTheme, isPrivate]);
+}
+function ThemeProvider(props) {
+  const {
+    children,
+    theme: localTheme,
+    themeId
+  } = props;
+  const upperTheme = useTheme(EMPTY_THEME);
+  const upperPrivateTheme = useTheme$1() || EMPTY_THEME;
+  if (process.env.NODE_ENV !== "production") {
+    if (upperTheme === null && typeof localTheme === "function" || themeId && upperTheme && !upperTheme[themeId] && typeof localTheme === "function") {
+      console.error(["MUI: You are providing a theme function prop to the ThemeProvider component:", "<ThemeProvider theme={outerTheme => outerTheme} />", "", "However, no outer theme is present.", "Make sure a theme is already injected higher in the React tree or provide a theme object."].join("\n"));
+    }
+  }
+  const engineTheme = useThemeScoping(themeId, upperTheme, localTheme);
+  const privateTheme = useThemeScoping(themeId, upperPrivateTheme, localTheme, true);
+  const rtlValue = engineTheme.direction === "rtl";
+  const layerOrder = useLayerOrder(engineTheme);
+  return /* @__PURE__ */ jsx(ThemeProvider$1, {
+    theme: privateTheme,
+    children: /* @__PURE__ */ jsx(ThemeContext.Provider, {
+      value: engineTheme,
+      children: /* @__PURE__ */ jsx(RtlProvider, {
+        value: rtlValue,
+        children: /* @__PURE__ */ jsxs(DefaultPropsProvider, {
+          value: engineTheme == null ? void 0 : engineTheme.components,
+          children: [layerOrder, children]
+        })
+      })
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Your component tree.
+   */
+  children: PropTypes.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
+  /**
+   * The design system's unique id for getting the corresponded theme when there are multiple design systems.
+   */
+  themeId: PropTypes.string
+} : void 0;
+if (process.env.NODE_ENV !== "production") {
+  process.env.NODE_ENV !== "production" ? ThemeProvider.propTypes = exactProp(ThemeProvider.propTypes) : void 0;
+}
+export {
+  ThemeProvider as default
+};

package/dist/node_modules/@mui/system/esm/ThemeProvider/useLayerOrder.js

@@ -0,0 +1,50 @@
+import "react";
+import useTheme from "../useThemeWithoutDefault.js";
+import { jsx } from "react/jsx-runtime";
+import useId from "../../node_modules/@mui/utils/esm/useId/useId.js";
+import useEnhancedEffect from "../../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js";
+import GlobalStyles from "../GlobalStyles/GlobalStyles.js";
+function useLayerOrder(theme) {
+  const upperTheme = useTheme();
+  const id = useId() || "";
+  const {
+    modularCssLayers
+  } = theme;
+  let layerOrder = "mui.global, mui.components, mui.theme, mui.custom, mui.sx";
+  if (!modularCssLayers || upperTheme !== null) {
+    layerOrder = "";
+  } else if (typeof modularCssLayers === "string") {
+    layerOrder = modularCssLayers.replace(/mui(?!\.)/g, layerOrder);
+  } else {
+    layerOrder = `@layer ${layerOrder};`;
+  }
+  useEnhancedEffect(() => {
+    const head = document.querySelector("head");
+    if (!head) {
+      return;
+    }
+    const firstChild = head.firstChild;
+    if (layerOrder) {
+      var _firstChild$hasAttrib;
+      if (firstChild && (_firstChild$hasAttrib = firstChild.hasAttribute) != null && _firstChild$hasAttrib.call(firstChild, "data-mui-layer-order") && firstChild.getAttribute("data-mui-layer-order") === id) {
+        return;
+      }
+      const styleElement = document.createElement("style");
+      styleElement.setAttribute("data-mui-layer-order", id);
+      styleElement.textContent = layerOrder;
+      head.prepend(styleElement);
+    } else {
+      var _head$querySelector;
+      (_head$querySelector = head.querySelector(`style[data-mui-layer-order="${id}"]`)) == null || _head$querySelector.remove();
+    }
+  }, [layerOrder, id]);
+  if (!layerOrder) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(GlobalStyles, {
+    styles: layerOrder
+  });
+}
+export {
+  useLayerOrder as default
+};

package/dist/node_modules/@mui/system/esm/createStyled.js

@@ -4,8 +4,8 @@ import styled, { internal_processStyles, internal_serializeStyles } from "../../
 import capitalize from "../node_modules/@mui/utils/esm/capitalize/capitalize.js";
 import getDisplayName from "../node_modules/@mui/utils/esm/getDisplayName/getDisplayName.js";
 import createTheme from "./createTheme/createTheme.js";
-import styleFunctionSx from "./styleFunctionSx/styleFunctionSx.js";
 import { isPlainObject } from "../node_modules/@mui/utils/esm/deepmerge/deepmerge.js";
+import styleFunctionSx from "./styleFunctionSx/styleFunctionSx.js";
 const _excluded = ["ownerState"], _excluded2 = ["variants"], _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"];
 function isEmpty(obj) {
   return Object.keys(obj).length === 0;

package/dist/node_modules/@mui/system/node_modules/@mui/utils/esm/exactProp/exactProp.js

@@ -0,0 +1,19 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+const specialProperty = "exact-prop: ​";
+function exactProp(propTypes) {
+  if (process.env.NODE_ENV === "production") {
+    return propTypes;
+  }
+  return _extends({}, propTypes, {
+    [specialProperty]: (props) => {
+      const unsupportedProps = Object.keys(props).filter((prop) => !propTypes.hasOwnProperty(prop));
+      if (unsupportedProps.length > 0) {
+        return new Error(`The following props are not supported: ${unsupportedProps.map((prop) => `\`${prop}\``).join(", ")}. Please remove them.`);
+      }
+      return null;
+    }
+  });
+}
+export {
+  exactProp as default
+};

package/dist/node_modules/@mui/system/node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js

@@ -0,0 +1,5 @@
+import * as React from "react";
+const useEnhancedEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
+export {
+  useEnhancedEffect as default
+};

package/dist/node_modules/@mui/system/node_modules/@mui/utils/esm/useId/useId.js

@@ -0,0 +1,24 @@
+import * as React from "react";
+let globalId = 0;
+function useGlobalId(idOverride) {
+  const [defaultId, setDefaultId] = React.useState(idOverride);
+  const id = idOverride || defaultId;
+  React.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`mui-${globalId}`);
+    }
+  }, [defaultId]);
+  return id;
+}
+const maybeReactUseId = React["useId".toString()];
+function useId(idOverride) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return reactId;
+  }
+  return useGlobalId(idOverride);
+}
+export {
+  useId as default
+};

package/dist/node_modules/call-bind/index.js

@@ -1,4 +1,4 @@
-import { __module as callBind } from "../../_virtual/index15.js";
+import { __module as callBind } from "../../_virtual/index14.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";
@@ -14,10 +14,10 @@ function requireCallBind() {
     var applyBind = requireApplyBind();
     module.exports = function callBind2(originalFunction) {
       var func = callBindBasic(arguments);
-      var adjustedLength = originalFunction.length - (arguments.length - 1);
+      var adjustedLength = 1 + originalFunction.length - (arguments.length - 1);
       return setFunctionLength(
         func,
-        1 + (adjustedLength > 0 ? adjustedLength : 0),
+        adjustedLength > 0 ? adjustedLength : 0,
         true
       );
     };

package/dist/node_modules/es-abstract/2025/ToString.js

@@ -0,0 +1,21 @@
+import { __require as requireGetIntrinsic } from "../../get-intrinsic/index.js";
+import { __require as requireType } from "../../es-errors/type.js";
+var ToString;
+var hasRequiredToString;
+function requireToString() {
+  if (hasRequiredToString) return ToString;
+  hasRequiredToString = 1;
+  var GetIntrinsic = requireGetIntrinsic();
+  var $String = GetIntrinsic("%String%");
+  var $TypeError = requireType();
+  ToString = function ToString2(argument) {
+    if (typeof argument === "symbol") {
+      throw new $TypeError("Cannot convert a Symbol value to a string");
+    }
+    return $String(argument);
+  };
+  return ToString;
+}
+export {
+  requireToString as __require
+};

package/dist/node_modules/es-abstract-get/GetMethod.js

@@ -0,0 +1,33 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireIsCallable } from "../is-callable/index.js";
+import { __require as requireObjectInspect } from "../object-inspect/index.js";
+import { __require as requireGetV } from "./GetV.js";
+import { __require as requireIsPropertyKey } from "./isPropertyKey.js";
+var GetMethod;
+var hasRequiredGetMethod;
+function requireGetMethod() {
+  if (hasRequiredGetMethod) return GetMethod;
+  hasRequiredGetMethod = 1;
+  var $TypeError = requireType();
+  var isCallable = requireIsCallable();
+  var inspect = requireObjectInspect();
+  var GetV = requireGetV();
+  var isPropertyKey = requireIsPropertyKey();
+  GetMethod = function GetMethod2(O, P) {
+    if (!isPropertyKey(P)) {
+      throw new $TypeError("Assertion failed: P is not a Property Key");
+    }
+    var func = GetV(O, P);
+    if (func == null) {
+      return void 0;
+    }
+    if (!isCallable(func)) {
+      throw new $TypeError(inspect(P) + " is not a function: " + inspect(func));
+    }
+    return func;
+  };
+  return GetMethod;
+}
+export {
+  requireGetMethod as __require
+};

package/dist/node_modules/es-abstract-get/GetV.js

@@ -0,0 +1,25 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireObjectInspect } from "../object-inspect/index.js";
+import { __require as requireIsPropertyKey } from "./isPropertyKey.js";
+var GetV;
+var hasRequiredGetV;
+function requireGetV() {
+  if (hasRequiredGetV) return GetV;
+  hasRequiredGetV = 1;
+  var $TypeError = requireType();
+  var inspect = requireObjectInspect();
+  var isPropertyKey = requireIsPropertyKey();
+  GetV = function GetV2(V, P) {
+    if (!isPropertyKey(P)) {
+      throw new $TypeError("Assertion failed: P is not a Property Key, got " + inspect(P));
+    }
+    return (
+      /** @type {Record<typeof P, unknown>} */
+      V[P]
+    );
+  };
+  return GetV;
+}
+export {
+  requireGetV as __require
+};

package/dist/node_modules/es-abstract-get/isPropertyKey.js

@@ -0,0 +1,13 @@
+var isPropertyKey;
+var hasRequiredIsPropertyKey;
+function requireIsPropertyKey() {
+  if (hasRequiredIsPropertyKey) return isPropertyKey;
+  hasRequiredIsPropertyKey = 1;
+  isPropertyKey = function isPropertyKey2(argument) {
+    return typeof argument === "string" || typeof argument === "symbol";
+  };
+  return isPropertyKey;
+}
+export {
+  requireIsPropertyKey as __require
+};

package/dist/node_modules/es-to-primitive/es2015.js

@@ -1,23 +1,26 @@
-import { __require as requireIsPrimitive } from "./helpers/isPrimitive.js";
 import { __require as requireIsCallable } from "../is-callable/index.js";
 import { __require as requireIsDateObject } from "../is-date-object/index.js";
 import { __require as requireIsSymbol } from "../is-symbol/index.js";
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireIsPrimitive } from "./helpers/isPrimitive.js";
+import { __require as requireGetMethod } from "../es-abstract-get/GetMethod.js";
 var es2015;
 var hasRequiredEs2015;
 function requireEs2015() {
   if (hasRequiredEs2015) return es2015;
   hasRequiredEs2015 = 1;
   var hasSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "symbol";
-  var isPrimitive = requireIsPrimitive();
   var isCallable = requireIsCallable();
   var isDate = requireIsDateObject();
   var isSymbol = requireIsSymbol();
-  var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
+  var $TypeError = requireType();
+  var isPrimitive = requireIsPrimitive();
+  function OrdinaryToPrimitive(O, hint) {
     if (typeof O === "undefined" || O === null) {
-      throw new TypeError("Cannot call method on " + O);
+      throw new $TypeError("Cannot call method on " + O);
     }
     if (typeof hint !== "string" || hint !== "number" && hint !== "string") {
-      throw new TypeError('hint must be "string" or "number"');
+      throw new $TypeError('hint must be "string" or "number"');
     }
     var methodNames = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
     var method, result, i;
@@ -26,25 +29,22 @@ function requireEs2015() {
       if (isCallable(method)) {
         result = method.call(O);
         if (isPrimitive(result)) {
-          return result;
+          return (
+            /** @type {primitiveES6} */
+            result
+          );
         }
       }
     }
-    throw new TypeError("No default value");
-  };
-  var GetMethod = function GetMethod2(O, P) {
-    var func = O[P];
-    if (func !== null && typeof func !== "undefined") {
-      if (!isCallable(func)) {
-        throw new TypeError(func + " returned for property " + String(P) + " of object " + O + " is not a function");
-      }
-      return func;
-    }
-    return void 0;
-  };
+    throw new $TypeError("No default value");
+  }
+  var GetMethod = requireGetMethod();
   es2015 = function ToPrimitive(input) {
     if (isPrimitive(input)) {
-      return input;
+      return (
+        /** @type {primitiveES6} */
+        input
+      );
     }
     var hint = "default";
     if (arguments.length > 1) {
@@ -58,7 +58,7 @@ function requireEs2015() {
     if (hasSymbols) {
       if (Symbol.toPrimitive) {
         exoticToPrim = GetMethod(
-          /** @type {Record<PropertyKey, unknown>} */
+          /** @type {{ [k in SymbolConstructor['toPrimitive']]?: Function }} */
           input,
           Symbol.toPrimitive
         );
@@ -69,18 +69,18 @@ function requireEs2015() {
     if (typeof exoticToPrim !== "undefined") {
       var result = exoticToPrim.call(input, hint);
       if (isPrimitive(result)) {
-        return result;
+        return (
+          /** @type {primitiveES6} */
+          result
+        );
       }
-      throw new TypeError("unable to convert exotic object to primitive");
+      throw new $TypeError("unable to convert exotic object to primitive");
     }
     if (hint === "default" && (isDate(input) || isSymbol(input))) {
-      hint = "string";
+      hint = /** @type {const} */
+      "string";
     }
-    return ordinaryToPrimitive(
-      /** @type {object} */
-      input,
-      hint === "default" ? "number" : hint
-    );
+    return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
   };
   return es2015;
 }