@ariakit/core 0.0.1 → 0.1.1

package/cjs/utils/events.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Returns `true` if `event` has been fired within a React Portal element.
+ */
+export declare function isPortalEvent(event: Pick<Event, "currentTarget" | "target">): boolean;
+/**
+ * Returns `true` if `event.target` and `event.currentTarget` are the same.
+ */
+export declare function isSelfTarget(event: Pick<Event, "target" | "currentTarget">): boolean;
+/**
+ * Checks whether the user event is triggering a page navigation in a new tab.
+ */
+export declare function isOpeningInNewTab(event: Pick<MouseEvent, "currentTarget" | "metaKey" | "ctrlKey">): boolean;
+/**
+ * Checks whether the user event is triggering a download.
+ */
+export declare function isDownloading(event: Pick<MouseEvent, "altKey" | "currentTarget">): boolean;
+/**
+ * Creates and dispatches an event.
+ * @example
+ * fireEvent(document.getElementById("id"), "blur", {
+ *   bubbles: true,
+ *   cancelable: true,
+ * });
+ */
+export declare function fireEvent(element: Element, type: string, eventInit?: EventInit): boolean;
+/**
+ * Creates and dispatches a blur event.
+ * @example
+ * fireBlurEvent(document.getElementById("id"));
+ */
+export declare function fireBlurEvent(element: Element, eventInit?: FocusEventInit): boolean;
+/**
+ * Creates and dispatches a focus event.
+ * @example
+ * fireFocusEvent(document.getElementById("id"));
+ */
+export declare function fireFocusEvent(element: Element, eventInit?: FocusEventInit): boolean;
+/**
+ * Creates and dispatches a keyboard event.
+ * @example
+ * fireKeyboardEvent(document.getElementById("id"), "keydown", {
+ *   key: "ArrowDown",
+ *   shiftKey: true,
+ * });
+ */
+export declare function fireKeyboardEvent(element: Element, type: string, eventInit?: KeyboardEventInit): boolean;
+/**
+ * Creates and dispatches a click event.
+ * @example
+ * fireClickEvent(document.getElementById("id"));
+ */
+export declare function fireClickEvent(element: Element, eventInit?: PointerEventInit): boolean;
+/**
+ * Checks whether the focus/blur event is happening from/to outside of the
+ * container element.
+ * @example
+ * const element = document.getElementById("id");
+ * element.addEventListener("blur", (event) => {
+ *   if (isFocusEventOutside(event)) {
+ *     // ...
+ *   }
+ * });
+ */
+export declare function isFocusEventOutside(event: Pick<FocusEvent, "currentTarget" | "relatedTarget">, container?: Element | null): boolean;
+/**
+ * Runs a callback on the next animation frame, but before a certain event.
+ */
+export declare function queueBeforeEvent(element: Element, type: string, callback: () => void): number;
+/**
+ * Adds a global event listener, including on child frames.
+ */
+export declare function addGlobalEventListener<K extends keyof DocumentEventMap>(type: K, listener: (event: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions, scope?: Window): () => void;
+export declare function addGlobalEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions, scope?: Window): () => void;

package/cjs/utils/focus.cjs

@@ -0,0 +1,222 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+var _OFNGELMAcjs = require('../__chunks/OFNGELMA.cjs');
+
+// src/utils/focus.ts
+var selector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false'])";
+function hasNegativeTabIndex(element) {
+  const tabIndex = parseInt(element.getAttribute("tabindex") || "0", 10);
+  return tabIndex < 0;
+}
+function isFocusable(element) {
+  return _OFNGELMAcjs.matches.call(void 0, element, selector) && _OFNGELMAcjs.isVisible.call(void 0, element);
+}
+function isTabbable(element) {
+  return isFocusable(element) && !hasNegativeTabIndex(element);
+}
+function getAllFocusableIn(container, includeContainer) {
+  const elements = Array.from(
+    container.querySelectorAll(selector)
+  );
+  if (includeContainer) {
+    elements.unshift(container);
+  }
+  const focusableElements = elements.filter(isFocusable);
+  focusableElements.forEach((element, i) => {
+    if (_OFNGELMAcjs.isFrame.call(void 0, element) && element.contentDocument) {
+      const frameBody = element.contentDocument.body;
+      focusableElements.splice(i, 1, ...getAllFocusableIn(frameBody));
+    }
+  });
+  return focusableElements;
+}
+function getAllFocusable(includeBody) {
+  return getAllFocusableIn(document.body, includeBody);
+}
+function getFirstFocusableIn(container, includeContainer) {
+  const [first] = getAllFocusableIn(container, includeContainer);
+  return first || null;
+}
+function getFirstFocusable(includeBody) {
+  return getFirstFocusableIn(document.body, includeBody);
+}
+function getAllTabbableIn(container, includeContainer, fallbackToFocusable) {
+  const elements = Array.from(
+    container.querySelectorAll(selector)
+  );
+  const tabbableElements = elements.filter(isTabbable);
+  if (includeContainer && isTabbable(container)) {
+    tabbableElements.unshift(container);
+  }
+  tabbableElements.forEach((element, i) => {
+    if (_OFNGELMAcjs.isFrame.call(void 0, element) && element.contentDocument) {
+      const frameBody = element.contentDocument.body;
+      const allFrameTabbable = getAllTabbableIn(
+        frameBody,
+        false,
+        fallbackToFocusable
+      );
+      tabbableElements.splice(i, 1, ...allFrameTabbable);
+    }
+  });
+  if (!tabbableElements.length && fallbackToFocusable) {
+    return elements;
+  }
+  return tabbableElements;
+}
+function getAllTabbable(fallbackToFocusable) {
+  return getAllTabbableIn(document.body, false, fallbackToFocusable);
+}
+function getFirstTabbableIn(container, includeContainer, fallbackToFocusable) {
+  const [first] = getAllTabbableIn(
+    container,
+    includeContainer,
+    fallbackToFocusable
+  );
+  return first || null;
+}
+function getFirstTabbable(fallbackToFocusable) {
+  return getFirstTabbableIn(document.body, false, fallbackToFocusable);
+}
+function getLastTabbableIn(container, includeContainer, fallbackToFocusable) {
+  const allTabbable = getAllTabbableIn(
+    container,
+    includeContainer,
+    fallbackToFocusable
+  );
+  return allTabbable[allTabbable.length - 1] || null;
+}
+function getLastTabbable(fallbackToFocusable) {
+  return getLastTabbableIn(document.body, false, fallbackToFocusable);
+}
+function getNextTabbableIn(container, includeContainer, fallbackToFirst, fallbackToFocusable) {
+  const activeElement = _OFNGELMAcjs.getActiveElement.call(void 0, container);
+  const allFocusable = getAllFocusableIn(container, includeContainer);
+  const activeIndex = allFocusable.indexOf(activeElement);
+  const nextFocusableElements = allFocusable.slice(activeIndex + 1);
+  return nextFocusableElements.find(isTabbable) || (fallbackToFirst ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? nextFocusableElements[0] : null) || null;
+}
+function getNextTabbable(fallbackToFirst, fallbackToFocusable) {
+  return getNextTabbableIn(
+    document.body,
+    false,
+    fallbackToFirst,
+    fallbackToFocusable
+  );
+}
+function getPreviousTabbableIn(container, includeContainer, fallbackToLast, fallbackToFocusable) {
+  const activeElement = _OFNGELMAcjs.getActiveElement.call(void 0, container);
+  const allFocusable = getAllFocusableIn(container, includeContainer).reverse();
+  const activeIndex = allFocusable.indexOf(activeElement);
+  const previousFocusableElements = allFocusable.slice(activeIndex + 1);
+  return previousFocusableElements.find(isTabbable) || (fallbackToLast ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? previousFocusableElements[0] : null) || null;
+}
+function getPreviousTabbable(fallbackToFirst, fallbackToFocusable) {
+  return getPreviousTabbableIn(
+    document.body,
+    false,
+    fallbackToFirst,
+    fallbackToFocusable
+  );
+}
+function getClosestFocusable(element) {
+  while (element && !isFocusable(element)) {
+    element = _OFNGELMAcjs.closest.call(void 0, element, selector);
+  }
+  return element || null;
+}
+function hasFocus(element) {
+  const activeElement = _OFNGELMAcjs.getActiveElement.call(void 0, element);
+  if (!activeElement)
+    return false;
+  if (activeElement === element)
+    return true;
+  const activeDescendant = activeElement.getAttribute("aria-activedescendant");
+  if (!activeDescendant)
+    return false;
+  return activeDescendant === element.id;
+}
+function hasFocusWithin(element) {
+  const activeElement = _OFNGELMAcjs.getActiveElement.call(void 0, element);
+  if (!activeElement)
+    return false;
+  if (_OFNGELMAcjs.contains.call(void 0, element, activeElement))
+    return true;
+  const activeDescendant = activeElement.getAttribute("aria-activedescendant");
+  if (!activeDescendant)
+    return false;
+  if (!("id" in element))
+    return false;
+  if (activeDescendant === element.id)
+    return true;
+  return !!element.querySelector(`#${CSS.escape(activeDescendant)}`);
+}
+function focusIfNeeded(element) {
+  if (!hasFocusWithin(element) && isFocusable(element)) {
+    element.focus();
+  }
+}
+function disableFocus(element) {
+  const currentTabindex = _nullishCoalesce(element.getAttribute("tabindex"), () => ( ""));
+  element.setAttribute("data-tabindex", currentTabindex);
+  element.setAttribute("tabindex", "-1");
+}
+function disableFocusIn(container, includeContainer) {
+  const tabbableElements = getAllTabbableIn(container, includeContainer);
+  tabbableElements.forEach(disableFocus);
+}
+function restoreFocusIn(container) {
+  const elements = container.querySelectorAll("[data-tabindex]");
+  const restoreTabIndex = (element) => {
+    const tabindex = element.getAttribute("data-tabindex");
+    element.removeAttribute("data-tabindex");
+    if (tabindex) {
+      element.setAttribute("tabindex", tabindex);
+    } else {
+      element.removeAttribute("tabindex");
+    }
+  };
+  if (container.hasAttribute("data-tabindex")) {
+    restoreTabIndex(container);
+  }
+  elements.forEach(restoreTabIndex);
+}
+function focusIntoView(element, options) {
+  if (!("scrollIntoView" in element)) {
+    element.focus();
+  } else {
+    element.focus({ preventScroll: true });
+    element.scrollIntoView({ block: "nearest", inline: "nearest", ...options });
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.disableFocus = disableFocus; exports.disableFocusIn = disableFocusIn; exports.focusIfNeeded = focusIfNeeded; exports.focusIntoView = focusIntoView; exports.getAllFocusable = getAllFocusable; exports.getAllFocusableIn = getAllFocusableIn; exports.getAllTabbable = getAllTabbable; exports.getAllTabbableIn = getAllTabbableIn; exports.getClosestFocusable = getClosestFocusable; exports.getFirstFocusable = getFirstFocusable; exports.getFirstFocusableIn = getFirstFocusableIn; exports.getFirstTabbable = getFirstTabbable; exports.getFirstTabbableIn = getFirstTabbableIn; exports.getLastTabbable = getLastTabbable; exports.getLastTabbableIn = getLastTabbableIn; exports.getNextTabbable = getNextTabbable; exports.getNextTabbableIn = getNextTabbableIn; exports.getPreviousTabbable = getPreviousTabbable; exports.getPreviousTabbableIn = getPreviousTabbableIn; exports.hasFocus = hasFocus; exports.hasFocusWithin = hasFocusWithin; exports.isFocusable = isFocusable; exports.isTabbable = isTabbable; exports.restoreFocusIn = restoreFocusIn;

package/cjs/utils/focus.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Checks whether `element` is focusable or not.
+ * @example
+ * isFocusable(document.querySelector("input")); // true
+ * isFocusable(document.querySelector("input[tabindex='-1']")); // true
+ * isFocusable(document.querySelector("input[hidden]")); // false
+ * isFocusable(document.querySelector("input:disabled")); // false
+ */
+export declare function isFocusable(element: Element): element is HTMLElement;
+/**
+ * Checks whether `element` is tabbable or not.
+ * @example
+ * isTabbable(document.querySelector("input")); // true
+ * isTabbable(document.querySelector("input[tabindex='-1']")); // false
+ * isTabbable(document.querySelector("input[hidden]")); // false
+ * isTabbable(document.querySelector("input:disabled")); // false
+ */
+export declare function isTabbable(element: Element): element is HTMLElement;
+/**
+ * Returns all the focusable elements in `container`.
+ */
+export declare function getAllFocusableIn(container: HTMLElement, includeContainer?: boolean): HTMLElement[];
+/**
+ * Returns all the focusable elements in the document.
+ */
+export declare function getAllFocusable(includeBody?: boolean): HTMLElement[];
+/**
+ * Returns the first focusable element in `container`.
+ */
+export declare function getFirstFocusableIn(container: HTMLElement, includeContainer?: boolean): HTMLElement | null;
+/**
+ * Returns the first focusable element in the document.
+ */
+export declare function getFirstFocusable(includeBody?: boolean): HTMLElement | null;
+/**
+ * Returns all the tabbable elements in `container`, including the container
+ * itself.
+ */
+export declare function getAllTabbableIn(container: HTMLElement, includeContainer?: boolean, fallbackToFocusable?: boolean): HTMLElement[];
+/**
+ * Returns all the tabbable elements in the document.
+ */
+export declare function getAllTabbable(fallbackToFocusable?: boolean): HTMLElement[];
+/**
+ * Returns the first tabbable element in `container`, including the container
+ * itself if it's tabbable.
+ */
+export declare function getFirstTabbableIn(container: HTMLElement, includeContainer?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the first tabbable element in the document.
+ */
+export declare function getFirstTabbable(fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the last tabbable element in `container`, including the container
+ * itself if it's tabbable.
+ */
+export declare function getLastTabbableIn(container: HTMLElement, includeContainer?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the last tabbable element in the document.
+ */
+export declare function getLastTabbable(fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the next tabbable element in `container`.
+ */
+export declare function getNextTabbableIn(container: HTMLElement, includeContainer?: boolean, fallbackToFirst?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the next tabbable element in the document.
+ */
+export declare function getNextTabbable(fallbackToFirst?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the previous tabbable element in `container`.
+ *
+ */
+export declare function getPreviousTabbableIn(container: HTMLElement, includeContainer?: boolean, fallbackToLast?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the previous tabbable element in the document.
+ */
+export declare function getPreviousTabbable(fallbackToFirst?: boolean, fallbackToFocusable?: boolean): HTMLElement | null;
+/**
+ * Returns the closest focusable element.
+ */
+export declare function getClosestFocusable(element?: HTMLElement | null): HTMLElement | null;
+/**
+ * Checks if `element` has focus. Elements that are referenced by
+ * `aria-activedescendant` are also considered.
+ * @example
+ * hasFocus(document.getElementById("id"));
+ */
+export declare function hasFocus(element: Element): boolean;
+/**
+ * Checks if `element` has focus within. Elements that are referenced by
+ * `aria-activedescendant` are also considered.
+ * @example
+ * hasFocusWithin(document.getElementById("id"));
+ */
+export declare function hasFocusWithin(element: Node | Element): boolean;
+/**
+ * Focus on an element only if it's not already focused.
+ */
+export declare function focusIfNeeded(element: HTMLElement): void;
+/**
+ * Disable focus on `element`.
+ */
+export declare function disableFocus(element: HTMLElement): void;
+/**
+ * Makes elements inside container not tabbable.
+ */
+export declare function disableFocusIn(container: HTMLElement, includeContainer?: boolean): void;
+/**
+ * Restores tabbable elements inside container that were affected by
+ * disableFocusIn.
+ */
+export declare function restoreFocusIn(container: HTMLElement): void;
+/**
+ * Focus on element and scroll into view.
+ */
+export declare function focusIntoView(element: HTMLElement, options?: ScrollIntoViewOptions): void;

package/cjs/utils/misc.cjs

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _5D5Y5EI4cjs = require('../__chunks/5D5Y5EI4.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.afterPaint = _5D5Y5EI4cjs.afterPaint; exports.applyState = _5D5Y5EI4cjs.applyState; exports.beforePaint = _5D5Y5EI4cjs.beforePaint; exports.chain = _5D5Y5EI4cjs.chain; exports.cx = _5D5Y5EI4cjs.cx; exports.defaultValue = _5D5Y5EI4cjs.defaultValue; exports.getKeys = _5D5Y5EI4cjs.getKeys; exports.hasOwnProperty = _5D5Y5EI4cjs.hasOwnProperty; exports.identity = _5D5Y5EI4cjs.identity; exports.invariant = _5D5Y5EI4cjs.invariant; exports.isEmpty = _5D5Y5EI4cjs.isEmpty; exports.isInteger = _5D5Y5EI4cjs.isInteger; exports.isObject = _5D5Y5EI4cjs.isObject; exports.noop = _5D5Y5EI4cjs.noop; exports.normalizeString = _5D5Y5EI4cjs.normalizeString; exports.omit = _5D5Y5EI4cjs.omit; exports.pick = _5D5Y5EI4cjs.pick; exports.shallowEqual = _5D5Y5EI4cjs.shallowEqual;

package/cjs/utils/misc.d.ts

@@ -0,0 +1,111 @@
+import type { AnyFunction, AnyObject, SetStateAction } from "./types.js";
+/**
+ * Empty function.
+ */
+export declare function noop(..._: any[]): any;
+/**
+ * Compares two objects.
+ * @example
+ * shallowEqual({ a: "a" }, {}); // false
+ * shallowEqual({ a: "a" }, { b: "b" }); // false
+ * shallowEqual({ a: "a" }, { a: "a" }); // true
+ * shallowEqual({ a: "a" }, { a: "a", b: "b" }); // false
+ */
+export declare function shallowEqual(a?: AnyObject, b?: AnyObject): boolean;
+/**
+ * Receives a `setState` argument and calls it with `currentValue` if it's a
+ * function. Otherwise return the argument as the new value.
+ * @example
+ * applyState((value) => value + 1, 1); // 2
+ * applyState(2, 1); // 2
+ */
+export declare function applyState<T>(argument: SetStateAction<T>, currentValue: T | (() => T)): T;
+/**
+ * Checks whether `arg` is an object or not.
+ * @returns {boolean}
+ */
+export declare function isObject(arg: any): arg is Record<any, unknown>;
+/**
+ * Checks whether `arg` is empty or not.
+ * @example
+ * isEmpty([]); // true
+ * isEmpty(["a"]); // false
+ * isEmpty({}); // true
+ * isEmpty({ a: "a" }); // false
+ * isEmpty(); // true
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty(""); // true
+ */
+export declare function isEmpty(arg: any): boolean;
+/**
+ * Checks whether `arg` is an integer or not.
+ * @example
+ * isInteger(1); // true
+ * isInteger(1.5); // false
+ * isInteger("1"); // true
+ * isInteger("1.5"); // false
+ */
+export declare function isInteger(arg: any): boolean;
+/**
+ * Checks whether `prop` is an own property of `obj` or not.
+ */
+export declare function hasOwnProperty<T extends AnyObject>(object: T, prop: keyof any): prop is keyof T;
+/**
+ * Receives functions as arguments and returns a new function that calls all.
+ */
+export declare function chain<T>(...fns: T[]): (...args: T extends AnyFunction ? Parameters<T> : never) => void;
+/**
+ * Returns a string with the truthy values of `args` separated by space.
+ */
+export declare function cx(...args: Array<string | null | false | 0 | undefined>): string | undefined;
+/**
+ * Removes diatrics from a string.
+ */
+export declare function normalizeString(str: string): string;
+/**
+ * Omits specific keys from an object.
+ * @example
+ * omit({ a: "a", b: "b" }, ["a"]); // { b: "b" }
+ */
+export declare function omit<T extends AnyObject, K extends keyof T>(object: T, keys: ReadonlyArray<K> | K[]): Omit<T, K>;
+/**
+ * Picks specific keys from an object.
+ * @example
+ * pick({ a: "a", b: "b" }, ["a"]); // { a: "a" }
+ */
+export declare function pick<T extends AnyObject, K extends keyof T>(object: T, paths: ReadonlyArray<K> | K[]): Pick<T, K>;
+/**
+ * Returns the same argument.
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * Runs right before the next paint.
+ */
+export declare function beforePaint(cb?: () => void): () => void;
+/**
+ * Runs after the next paint.
+ */
+export declare function afterPaint(cb?: () => void): () => void;
+/**
+ * Asserts that a condition is true, otherwise throws an error.
+ * @example
+ * invariant(
+ *   condition,
+ *   process.env.NODE_ENV !== "production" && "Invariant failed"
+ * );
+ */
+export declare function invariant(condition: any, message?: string | boolean): asserts condition;
+/**
+ * Similar to `Object.keys` but returns a type-safe array of keys.
+ */
+export declare function getKeys<T extends object>(obj: T): (keyof T)[];
+/**
+ * Returns the first value that is not `undefined`.
+ */
+export declare function defaultValue<T extends readonly any[]>(...values: T): DefaultValue<T>;
+type DefinedArray<T extends readonly any[]> = {
+    [K in keyof T as undefined extends T[K] ? never : K]: undefined extends T[K] ? [Exclude<T[K], undefined>, never] : [T[K]];
+};
+type DefaultValue<T extends readonly any[]> = DefinedArray<T>[keyof DefinedArray<T>] extends [any, never] ? T[number] : DefinedArray<T>[keyof DefinedArray<T>][0];
+export {};

package/cjs/utils/platform.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _2YFRPUZPcjs = require('../__chunks/2YFRPUZP.cjs');
+require('../__chunks/OFNGELMA.cjs');
+
+
+
+
+
+
+exports.isApple = _2YFRPUZPcjs.isApple; exports.isFirefox = _2YFRPUZPcjs.isFirefox; exports.isMac = _2YFRPUZPcjs.isMac; exports.isSafari = _2YFRPUZPcjs.isSafari; exports.isTouchDevice = _2YFRPUZPcjs.isTouchDevice;

package/cjs/utils/platform.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Detects if the device has touch capabilities.
+ */
+export declare function isTouchDevice(): boolean;
+/**
+ * Detects Apple device.
+ */
+export declare function isApple(): boolean;
+/**
+ * Detects Safari browser.
+ */
+export declare function isSafari(): boolean;
+/**
+ * Detects Firefox browser.
+ */
+export declare function isFirefox(): boolean;
+/**
+ * Detects Mac computer.
+ */
+export declare function isMac(): boolean;

package/cjs/utils/store.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _3BBA3Z5Gcjs = require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+
+
+
+exports.createStore = _3BBA3Z5Gcjs.createStore; exports.mergeStore = _3BBA3Z5Gcjs.mergeStore;