@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/chunk-TBJCJXK4.js

@@ -0,0 +1,18 @@
+// src/instrumenter/EVENTS.ts
+var EVENTS = {
+  CALL: "@aussieljk/forkbook/instrumenter/call",
+  SYNC: "@aussieljk/forkbook/instrumenter/sync",
+  START: "@aussieljk/forkbook/instrumenter/start",
+  BACK: "@aussieljk/forkbook/instrumenter/back",
+  GOTO: "@aussieljk/forkbook/instrumenter/goto",
+  NEXT: "@aussieljk/forkbook/instrumenter/next",
+  END: "@aussieljk/forkbook/instrumenter/end"
+};
+
+// src/instrumenter/types.ts
+var CallStates = /* @__PURE__ */ ((CallStates2) => (CallStates2.DONE = "done", CallStates2.ERROR = "error", CallStates2.ACTIVE = "active", CallStates2.WAITING = "waiting", CallStates2))(CallStates || {});
+
+export {
+  EVENTS,
+  CallStates
+};

package/dist/_browser-chunks/chunk-UMDO3KB7.js

@@ -0,0 +1,205 @@
+// ../../node_modules/@gorhom/portal/lib/module/components/portalHost/PortalHost.js
+import React, { memo, useEffect } from "react";
+
+// ../../node_modules/@gorhom/portal/lib/module/hooks/usePortalState.js
+import { useContext } from "react";
+
+// ../../node_modules/@gorhom/portal/lib/module/contexts/portal.js
+import { createContext } from "react";
+var PortalStateContext = createContext(null), PortalDispatchContext = createContext(null);
+
+// ../../node_modules/@gorhom/portal/lib/module/hooks/usePortalState.js
+var usePortalState = (hostName) => {
+  let state = useContext(PortalStateContext);
+  if (state === null)
+    throw new Error("'PortalStateContext' cannot be null, please add 'PortalProvider' to the root component.");
+  return state[hostName] || [];
+};
+
+// ../../node_modules/@gorhom/portal/lib/module/hooks/usePortal.js
+import { useCallback, useContext as useContext2 } from "react";
+
+// ../../node_modules/@gorhom/portal/lib/module/state/constants.js
+var ACTIONS;
+(function(ACTIONS2) {
+  ACTIONS2[ACTIONS2.REGISTER_HOST = 0] = "REGISTER_HOST", ACTIONS2[ACTIONS2.DEREGISTER_HOST = 1] = "DEREGISTER_HOST", ACTIONS2[ACTIONS2.ADD_UPDATE_PORTAL = 2] = "ADD_UPDATE_PORTAL", ACTIONS2[ACTIONS2.REMOVE_PORTAL = 3] = "REMOVE_PORTAL";
+})(ACTIONS || (ACTIONS = {}));
+var INITIAL_STATE = {};
+
+// ../../node_modules/@gorhom/portal/lib/module/hooks/usePortal.js
+var usePortal = (hostName = "root") => {
+  let dispatch = useContext2(PortalDispatchContext);
+  if (dispatch === null)
+    throw new Error("'PortalDispatchContext' cannot be null, please add 'PortalProvider' to the root component.");
+  let registerHost2 = useCallback(() => {
+    dispatch({
+      type: ACTIONS.REGISTER_HOST,
+      hostName
+    });
+  }, []), deregisterHost2 = useCallback(() => {
+    dispatch({
+      type: ACTIONS.DEREGISTER_HOST,
+      hostName
+    });
+  }, []), addUpdatePortal2 = useCallback((name, node) => {
+    dispatch({
+      type: ACTIONS.ADD_UPDATE_PORTAL,
+      hostName,
+      portalName: name,
+      node
+    });
+  }, []), removePortal2 = useCallback((name) => {
+    dispatch({
+      type: ACTIONS.REMOVE_PORTAL,
+      hostName,
+      portalName: name
+    });
+  }, []);
+  return {
+    registerHost: registerHost2,
+    deregisterHost: deregisterHost2,
+    addPortal: addUpdatePortal2,
+    updatePortal: addUpdatePortal2,
+    removePortal: removePortal2
+  };
+};
+
+// ../../node_modules/@gorhom/portal/lib/module/components/portalHost/PortalHost.js
+var PortalHostComponent = ({
+  name
+}) => {
+  let state = usePortalState(name), {
+    registerHost: registerHost2,
+    deregisterHost: deregisterHost2
+  } = usePortal(name);
+  return useEffect(() => (registerHost2(), () => {
+    deregisterHost2();
+  }), []), React.createElement(React.Fragment, null, state.map((item) => item.node));
+}, PortalHost = memo(PortalHostComponent);
+PortalHost.displayName = "PortalHost";
+
+// ../../node_modules/@gorhom/portal/lib/module/components/portal/Portal.js
+import { memo as memo2, useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef } from "react";
+
+// ../../node_modules/@gorhom/portal/node_modules/nanoid/non-secure/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var nanoid = (size = 21) => {
+  let id = "", i = size | 0;
+  for (; i-- > 0; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+};
+
+// ../../node_modules/@gorhom/portal/lib/module/components/portal/Portal.js
+var PortalComponent = ({
+  name: _providedName,
+  hostName,
+  handleOnMount: _providedHandleOnMount,
+  handleOnUnmount: _providedHandleOnUnmount,
+  handleOnUpdate: _providedHandleOnUpdate,
+  children
+}) => {
+  let {
+    addPortal: addUpdatePortal2,
+    removePortal: removePortal2
+  } = usePortal(hostName), name = useMemo(() => _providedName || nanoid(), [_providedName]), handleOnMountRef = useRef(), handleOnUnmountRef = useRef(), handleOnUpdateRef = useRef(), handleOnMount = useCallback2(() => {
+    _providedHandleOnMount ? _providedHandleOnMount(() => addUpdatePortal2(name, children)) : addUpdatePortal2(name, children);
+  }, [_providedHandleOnMount, addUpdatePortal2]);
+  handleOnMountRef.current = handleOnMount;
+  let handleOnUnmount = useCallback2(() => {
+    _providedHandleOnUnmount ? _providedHandleOnUnmount(() => removePortal2(name)) : removePortal2(name);
+  }, [_providedHandleOnUnmount, removePortal2]);
+  handleOnUnmountRef.current = handleOnUnmount;
+  let handleOnUpdate = useCallback2(() => {
+    _providedHandleOnUpdate ? _providedHandleOnUpdate(() => addUpdatePortal2(name, children)) : addUpdatePortal2(name, children);
+  }, [_providedHandleOnUpdate, addUpdatePortal2, children]);
+  return handleOnUpdateRef.current = handleOnUpdate, useEffect2(() => {
+    var _handleOnMountRef$cur;
+    return (_handleOnMountRef$cur = handleOnMountRef.current) === null || _handleOnMountRef$cur === void 0 || _handleOnMountRef$cur.call(handleOnMountRef), () => {
+      var _handleOnUnmountRef$c;
+      (_handleOnUnmountRef$c = handleOnUnmountRef.current) === null || _handleOnUnmountRef$c === void 0 || _handleOnUnmountRef$c.call(handleOnUnmountRef), handleOnMountRef.current = void 0, handleOnUnmountRef.current = void 0, handleOnUpdateRef.current = void 0;
+    };
+  }, []), useEffect2(() => {
+    var _handleOnUpdateRef$cu;
+    (_handleOnUpdateRef$cu = handleOnUpdateRef.current) === null || _handleOnUpdateRef$cu === void 0 || _handleOnUpdateRef$cu.call(handleOnUpdateRef);
+  }, [children]), null;
+}, Portal = memo2(PortalComponent);
+Portal.displayName = "Portal";
+
+// ../../node_modules/@gorhom/portal/lib/module/components/portalProvider/PortalProvider.js
+import React2, { memo as memo3, useReducer } from "react";
+
+// ../../node_modules/@gorhom/portal/lib/module/utilities/logger.js
+var isLoggingEnabled = !1, isDev = !!(typeof __DEV__ < "u" && __DEV__);
+var print = () => {
+};
+isDev && (print = ({
+  component,
+  method,
+  params
+}) => {
+  if (!isLoggingEnabled)
+    return;
+  let message = "";
+  typeof params == "object" ? message = Object.keys(params).map((key) => "".concat(key, ":").concat(params[key])).join(" ") : message = "".concat(params ?? ""), console.log("[Portal::".concat([component, method].filter(Boolean).join("::"), "]"), message);
+});
+Object.freeze(print);
+
+// ../../node_modules/@gorhom/portal/lib/module/state/reducer.js
+var registerHost = (state, hostName) => (hostName in state || (state[hostName] = []), state), deregisterHost = (state, hostName) => (delete state[hostName], state), addUpdatePortal = (state, hostName, portalName, node) => {
+  hostName in state || (state = registerHost(state, hostName));
+  let index = state[hostName].findIndex((item) => item.name === portalName);
+  return index !== -1 ? state[hostName][index].node = node : state[hostName].push({
+    name: portalName,
+    node
+  }), state;
+}, removePortal = (state, hostName, portalName) => {
+  if (!(hostName in state))
+    return print({
+      component: reducer.name,
+      method: removePortal.name,
+      params: "Failed to remove portal '".concat(portalName, "', '").concat(hostName, "' was not registered!")
+    }), state;
+  let index = state[hostName].findIndex((item) => item.name === portalName);
+  return index !== -1 && state[hostName].splice(index, 1), state;
+}, reducer = (state, action) => {
+  let {
+    type
+  } = action, clonedState = {
+    ...state
+  };
+  switch (type) {
+    case ACTIONS.REGISTER_HOST:
+      return registerHost(clonedState, action.hostName);
+    case ACTIONS.DEREGISTER_HOST:
+      return deregisterHost(clonedState, action.hostName);
+    case ACTIONS.ADD_UPDATE_PORTAL:
+      return addUpdatePortal(clonedState, action.hostName, action.portalName, action.node);
+    case ACTIONS.REMOVE_PORTAL:
+      return removePortal(clonedState, action.hostName, action.portalName);
+    default:
+      return state;
+  }
+};
+
+// ../../node_modules/@gorhom/portal/lib/module/components/portalProvider/PortalProvider.js
+var PortalProviderComponent = ({
+  rootHostName = "root",
+  shouldAddRootHost = !0,
+  children
+}) => {
+  let [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+  return React2.createElement(PortalDispatchContext.Provider, {
+    value: dispatch
+  }, React2.createElement(PortalStateContext.Provider, {
+    value: state
+  }, children, shouldAddRootHost && React2.createElement(PortalHost, {
+    name: rootHostName
+  })));
+}, PortalProvider = memo3(PortalProviderComponent);
+PortalProvider.displayName = "PortalProvider";
+
+export {
+  Portal,
+  PortalHost
+};

package/dist/_browser-chunks/chunk-V2G23FV7.js

@@ -0,0 +1,11 @@
+// src/actions/constants.ts
+var PARAM_KEY = "actions", ADDON_ID = "@aussieljk/forkbook/actions", PANEL_ID = `${ADDON_ID}/panel`, EVENT_ID = `${ADDON_ID}/action-event`, CLEAR_ID = `${ADDON_ID}/action-clear`, CYCLIC_KEY = "$___storybook.isCyclic";
+
+export {
+  PARAM_KEY,
+  ADDON_ID,
+  PANEL_ID,
+  EVENT_ID,
+  CLEAR_ID,
+  CYCLIC_KEY
+};

package/dist/_browser-chunks/chunk-V5M7Q4HT.js

@@ -0,0 +1,88 @@
+// src/storybook-error.ts
+function parseErrorCode({
+  code,
+  category
+}) {
+  let paddedCode = String(code).padStart(4, "0");
+  return `SB_${category}_${paddedCode}`;
+}
+function appendErrorRef(url) {
+  if (/^(?!.*storybook\.js\.org)|[?&]ref=error\b/.test(url))
+    return url;
+  try {
+    let urlObj = new URL(url);
+    return urlObj.searchParams.set("ref", "error"), urlObj.toString();
+  } catch {
+    return url;
+  }
+}
+var StorybookError = class _StorybookError extends Error {
+  constructor(props) {
+    super(
+      _StorybookError.getFullMessage(props),
+      props.cause === void 0 ? void 0 : { cause: props.cause }
+    );
+    /**
+     * Data associated with the error. Used to provide additional information in the error message or
+     * to be passed to telemetry.
+     */
+    this.data = {};
+    /** Flag used to easily determine if the error originates from Forkbook. */
+    this.fromStorybook = !0;
+    /**
+     * Flag used to determine if the error is handled by us and should therefore not be shown to the
+     * user.
+     */
+    this.isHandledError = !1;
+    /**
+     * A collection of sub errors which relate to a parent error.
+     *
+     * Sub-errors are used to represent multiple related errors that occurred together. When a
+     * StorybookError with sub-errors is sent to telemetry, both the parent error and each sub-error
+     * are sent as separate telemetry events. This allows for better error tracking and debugging.
+     *
+     * @example
+     *
+     * ```ts
+     * const error1 = new SomeError();
+     * const error2 = new AnotherError();
+     * const parentError = new ParentError({
+     *   // ... other props
+     *   subErrors: [error1, error2],
+     * });
+     * ```
+     */
+    this.subErrors = [];
+    this.category = props.category, this.documentation = props.documentation ?? !1, this.code = props.code, this.isHandledError = props.isHandledError ?? !1, this.agentFacing = props.agentFacing ?? !1, this.name = props.name, this.subErrors = props.subErrors ?? [];
+  }
+  get fullErrorCode() {
+    return parseErrorCode({ code: this.code, category: this.category });
+  }
+  /** Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>. */
+  get name() {
+    let errorName = this._name || this.constructor.name;
+    return `${this.fullErrorCode} (${errorName})`;
+  }
+  set name(name) {
+    this._name = name;
+  }
+  /** Generates the error message along with additional documentation link (if applicable). */
+  static getFullMessage({
+    documentation,
+    code,
+    category,
+    message
+  }) {
+    let page;
+    return documentation === !0 ? page = `https://storybook.js.org/error/${parseErrorCode({ code, category })}?ref=error` : typeof documentation == "string" ? page = appendErrorRef(documentation) : Array.isArray(documentation) && (page = `
+${documentation.map((doc) => `	- ${appendErrorRef(doc)}`).join(`
+`)}`), `${message}${page != null ? `
+
+More info: ${page}
+` : ""}`;
+  }
+};
+
+export {
+  StorybookError
+};

package/dist/_browser-chunks/chunk-W5M6NPS3.js

@@ -0,0 +1,198 @@
+import {
+  filterDefs,
+  filters
+} from "./chunk-2JT76G3E.js";
+import {
+  EVENTS,
+  PANEL_ID
+} from "./chunk-OZZPSYQR.js";
+import {
+  __export
+} from "./chunk-IMSF75WX.js";
+
+// src/addon-a11y/preview.tsx
+var preview_exports = {};
+__export(preview_exports, {
+  afterEach: () => afterEach,
+  decorators: () => decorators,
+  initialGlobals: () => initialGlobals,
+  parameters: () => parameters
+});
+import { expect } from "@aussieljk/forkbook/test";
+
+// src/addon-a11y/a11yRunner.ts
+import { ElementA11yParameterError } from "@aussieljk/forkbook/internal/preview-errors";
+import { global as global2 } from "@storybook/global";
+import { addons, waitForAnimations } from "@aussieljk/forkbook/preview-api";
+
+// src/addon-a11y/a11yRunnerUtils.ts
+import { global } from "@storybook/global";
+var { document: document2 } = global, withLinkPaths = (results, storyId) => {
+  let pathname = document2.location.pathname.replace(/iframe\.html$/, ""), enhancedResults = { ...results };
+  return ["incomplete", "passes", "violations"].forEach((key) => {
+    Array.isArray(results[key]) && (enhancedResults[key] = results[key].map((result) => ({
+      ...result,
+      nodes: result.nodes.map((node, index) => {
+        let id = `${key}.${result.id}.${index + 1}`, linkPath = `${pathname}?path=/story/${storyId}&addonPanel=${PANEL_ID}&a11ySelection=${id}`;
+        return { id, ...node, linkPath };
+      })
+    })));
+  }), enhancedResults;
+};
+
+// src/addon-a11y/a11yRunner.ts
+var { document: document3 } = global2, channel = addons.getChannel(), DEFAULT_PARAMETERS = { config: {}, options: {} }, DISABLED_RULES = [
+  // In component testing, landmarks are not always present
+  // and the rule check can cause false positives
+  "region"
+], getDisabledRules = (rules = []) => {
+  let disabledRules = {};
+  for (let { id, enabled } of rules)
+    !id || typeof enabled != "boolean" || (enabled ? delete disabledRules[id] : disabledRules[id] = { enabled: !1 });
+  return disabledRules;
+}, mergeDisabledRulesIntoRunOptions = (options, config) => {
+  if (!options.runOnly)
+    return options;
+  let disabledRules = getDisabledRules(config.rules);
+  return Object.keys(disabledRules).length === 0 ? options : {
+    ...options,
+    rules: {
+      ...disabledRules,
+      ...options.rules
+    }
+  };
+}, queue = [], isRunning = !1, runNext = async () => {
+  if (queue.length === 0) {
+    isRunning = !1;
+    return;
+  }
+  isRunning = !0;
+  let next = queue.shift();
+  next && await next(), runNext();
+}, run = async (input = DEFAULT_PARAMETERS, storyId) => {
+  let axe = (await import("axe-core"))?.default || globalThis.axe, { config = {}, options = {} } = input;
+  if (input.element)
+    throw new ElementA11yParameterError();
+  let context = {
+    include: document3?.body,
+    exclude: [".sb-wrapper", "#storybook-docs", "#storybook-highlights-root"]
+    // Internal Forkbook elements that are always in the document
+  };
+  if (input.context) {
+    let hasInclude = typeof input.context == "object" && "include" in input.context && input.context.include !== void 0, hasExclude = typeof input.context == "object" && "exclude" in input.context && input.context.exclude !== void 0;
+    hasInclude ? context.include = input.context.include : !hasInclude && !hasExclude && (context.include = input.context), hasExclude && (context.exclude = context.exclude.concat(input.context.exclude));
+  }
+  axe.reset();
+  let configWithDefault = {
+    ...config,
+    rules: [...DISABLED_RULES.map((id) => ({ id, enabled: !1 })), ...config?.rules ?? []]
+  };
+  axe.configure(configWithDefault);
+  let optionsWithDisabledRules = mergeDisabledRulesIntoRunOptions(options, configWithDefault);
+  return new Promise((resolve, reject) => {
+    let highlightsRoot = document3?.getElementById("storybook-highlights-root");
+    highlightsRoot && (highlightsRoot.style.display = "none");
+    let task = async () => {
+      try {
+        let result = await axe.run(context, optionsWithDisabledRules), resultWithLinks = withLinkPaths(result, storyId);
+        resolve(resultWithLinks);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    queue.push(task), isRunning || runNext(), highlightsRoot && (highlightsRoot.style.display = "");
+  });
+};
+channel.on(EVENTS.MANUAL, async (storyId, input = DEFAULT_PARAMETERS) => {
+  try {
+    await waitForAnimations();
+    let result = await run(input, storyId), resultJson = JSON.parse(JSON.stringify(result));
+    channel.emit(EVENTS.RESULT, resultJson, storyId);
+  } catch (error) {
+    channel.emit(EVENTS.ERROR, error);
+  }
+});
+
+// src/addon-a11y/utils.ts
+function getIsVitestStandaloneRun() {
+  try {
+    return import.meta.env.VITEST_STORYBOOK === "false";
+  } catch {
+    return !1;
+  }
+}
+
+// src/addon-a11y/withVisionSimulator.ts
+import { useCallback, useEffect } from "@aussieljk/forkbook/preview-api";
+var knownFilters = Object.values(filters).map((f) => f.filter), knownFiltersRegExp = new RegExp(`\\b(${knownFilters.join("|")})\\b`, "g"), withVisionSimulator = (StoryFn, { globals }) => {
+  let { vision } = globals, applyVisionFilter = useCallback(() => {
+    let existingFilters = document.body.style.filter.replaceAll(knownFiltersRegExp, "").trim(), visionFilter = filters[vision]?.filter;
+    return visionFilter && document.body.classList.contains("sb-show-main") ? !existingFilters || existingFilters === "none" ? document.body.style.filter = visionFilter : document.body.style.filter = `${existingFilters} ${visionFilter}` : document.body.style.filter = existingFilters || "none", () => document.body.style.filter = existingFilters || "none";
+  }, [vision]);
+  return useEffect(() => {
+    let cleanup = applyVisionFilter(), observer = new MutationObserver(() => applyVisionFilter());
+    return observer.observe(document.body, { attributeFilter: ["class"] }), () => {
+      cleanup(), observer.disconnect();
+    };
+  }, [applyVisionFilter]), useEffect(() => (document.body.insertAdjacentHTML("beforeend", filterDefs), () => {
+    let filterDefsElement = document.getElementById("storybook-a11y-vision-filters");
+    filterDefsElement?.parentElement?.removeChild(filterDefsElement);
+  }), []), StoryFn();
+};
+
+// src/addon-a11y/preview.tsx
+var vitestMatchersExtended = !1, decorators = [withVisionSimulator], afterEach = async ({
+  id: storyId,
+  reporting,
+  parameters: parameters2,
+  globals,
+  viewMode
+}) => {
+  let a11yParameter = parameters2.a11y, a11yGlobals = globals.a11y, shouldRunEnvironmentIndependent = !!!globals.ghostStories && a11yParameter?.disable !== !0 && a11yParameter?.test !== "off" && a11yGlobals?.manual !== !0, getMode = () => a11yParameter?.test === "todo" ? "warning" : "failed";
+  if (shouldRunEnvironmentIndependent && viewMode === "story")
+    try {
+      let result = await run(a11yParameter, storyId);
+      if (result) {
+        let hasViolations = (result?.violations.length ?? 0) > 0;
+        if (reporting.addReport({
+          type: "a11y",
+          version: 1,
+          result,
+          status: hasViolations ? getMode() : "passed"
+        }), getIsVitestStandaloneRun() && hasViolations && getMode() === "failed") {
+          if (!vitestMatchersExtended) {
+            let { toHaveNoViolations } = await import("./matchers-YLBYSYAF.js");
+            expect.extend({ toHaveNoViolations }), vitestMatchersExtended = !0;
+          }
+          expect(result).toHaveNoViolations();
+        }
+      }
+    } catch (e) {
+      if (reporting.addReport({
+        type: "a11y",
+        version: 1,
+        result: {
+          error: e
+        },
+        status: "failed"
+      }), getIsVitestStandaloneRun())
+        throw e;
+    }
+}, initialGlobals = {
+  a11y: {
+    manual: !1
+  },
+  vision: void 0
+}, parameters = {
+  a11y: {
+    test: "todo"
+  }
+};
+
+export {
+  decorators,
+  afterEach,
+  initialGlobals,
+  parameters,
+  preview_exports
+};

package/dist/_browser-chunks/chunk-W7NE2JXW.js

@@ -0,0 +1,84 @@
+import {
+  globalThis_
+} from "./chunk-JPUOQJUI.js";
+
+// ../../node_modules/es-toolkit/dist/function/debounce.mjs
+function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis, pendingArgs = null, leading = edges != null && edges.includes("leading"), trailing = edges == null || edges.includes("trailing"), invoke = () => {
+    pendingArgs !== null && (func.apply(pendingThis, pendingArgs), pendingThis = void 0, pendingArgs = null);
+  }, onTimerEnd = () => {
+    trailing && invoke(), cancel();
+  }, timeoutId = null, schedule = () => {
+    timeoutId != null && clearTimeout(timeoutId), timeoutId = setTimeout(() => {
+      timeoutId = null, onTimerEnd();
+    }, debounceMs);
+  }, cancelTimer = () => {
+    timeoutId !== null && (clearTimeout(timeoutId), timeoutId = null);
+  }, cancel = () => {
+    cancelTimer(), pendingThis = void 0, pendingArgs = null;
+  }, flush = () => {
+    invoke();
+  }, debounced = function(...args) {
+    if (signal?.aborted) return;
+    pendingThis = this, pendingArgs = args;
+    let isFirstCall = timeoutId == null;
+    schedule(), leading && isFirstCall && invoke();
+  };
+  return debounced.schedule = schedule, debounced.cancel = cancel, debounced.flush = flush, signal?.addEventListener("abort", cancel, { once: !0 }), debounced;
+}
+
+// ../../node_modules/es-toolkit/dist/function/partial.mjs
+function partial(func, ...partialArgs) {
+  return partialImpl(func, placeholderSymbol, ...partialArgs);
+}
+function partialImpl(func, placeholder, ...partialArgs) {
+  let partialed = function(...providedArgs) {
+    let providedArgsIndex = 0, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg), remainingArgs = providedArgs.slice(providedArgsIndex);
+    return func.apply(this, substitutedArgs.concat(remainingArgs));
+  };
+  return func.prototype && (partialed.prototype = Object.create(func.prototype)), partialed;
+}
+var placeholderSymbol = /* @__PURE__ */ Symbol("partial.placeholder");
+partial.placeholder = placeholderSymbol;
+
+// ../../node_modules/es-toolkit/dist/function/partialRight.mjs
+function partialRight(func, ...partialArgs) {
+  return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
+}
+function partialRightImpl(func, placeholder, ...partialArgs) {
+  let partialedRight = function(...providedArgs) {
+    let placeholderLength = partialArgs.filter((arg) => arg === placeholder).length, rangeLength = Math.max(providedArgs.length - placeholderLength, 0), remainingArgs = providedArgs.slice(0, rangeLength), providedArgsIndex = rangeLength, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    return func.apply(this, remainingArgs.concat(substitutedArgs));
+  };
+  return func.prototype && (partialedRight.prototype = Object.create(func.prototype)), partialedRight;
+}
+var placeholderSymbol2 = /* @__PURE__ */ Symbol("partialRight.placeholder");
+partialRight.placeholder = placeholderSymbol2;
+
+// ../../node_modules/es-toolkit/dist/_internal/DOMException.mjs
+var DOMException = typeof globalThis_.DOMException < "u" ? globalThis_.DOMException : Error;
+
+// ../../node_modules/es-toolkit/dist/function/retry.mjs
+var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+
+// ../../node_modules/es-toolkit/dist/function/throttle.mjs
+function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
+  let pendingAt = null, debounced = debounce(function(...args) {
+    pendingAt = Date.now(), func.apply(this, args);
+  }, throttleMs, {
+    signal,
+    edges
+  }), throttled = function(...args) {
+    if (pendingAt == null && (pendingAt = Date.now()), Date.now() - pendingAt >= throttleMs) {
+      pendingAt = Date.now(), func.apply(this, args), debounced.cancel(), debounced.schedule();
+      return;
+    }
+    debounced.apply(this, args);
+  };
+  return throttled.cancel = debounced.cancel, throttled.flush = debounced.flush, throttled;
+}
+
+export {
+  debounce,
+  throttle
+};