@ariakit/core 0.0.1 → 0.1.0

package/cjs/__chunks/5D5Y5EI4.cjs

@@ -0,0 +1,146 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/misc.ts
+function noop(..._) {
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a)
+    return false;
+  if (!b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (typeof b !== "object")
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  const { length } = aKeys;
+  if (bKeys.length !== length)
+    return false;
+  for (const key of aKeys) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyState(argument, currentValue) {
+  if (isUpdater(argument)) {
+    const value = isLazyValue(currentValue) ? currentValue() : currentValue;
+    return argument(value);
+  }
+  return argument;
+}
+function isUpdater(argument) {
+  return typeof argument === "function";
+}
+function isLazyValue(value) {
+  return typeof value === "function";
+}
+function isObject(arg) {
+  return typeof arg === "object" && arg != null;
+}
+function isEmpty(arg) {
+  if (Array.isArray(arg))
+    return !arg.length;
+  if (isObject(arg))
+    return !Object.keys(arg).length;
+  if (arg == null)
+    return true;
+  if (arg === "")
+    return true;
+  return false;
+}
+function isInteger(arg) {
+  if (typeof arg === "number") {
+    return Math.floor(arg) === arg;
+  }
+  return String(Math.floor(Number(arg))) === arg;
+}
+function hasOwnProperty(object, prop) {
+  return Object.prototype.hasOwnProperty.call(object, prop);
+}
+function chain(...fns) {
+  return (...args) => {
+    for (const fn of fns) {
+      if (typeof fn === "function") {
+        fn(...args);
+      }
+    }
+  };
+}
+function cx(...args) {
+  return args.filter(Boolean).join(" ") || void 0;
+}
+function normalizeString(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function omit(object, keys) {
+  const result = { ...object };
+  for (const key of keys) {
+    if (hasOwnProperty(result, key)) {
+      delete result[key];
+    }
+  }
+  return result;
+}
+function pick(object, paths) {
+  const result = {};
+  for (const key of paths) {
+    if (hasOwnProperty(object, key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+function identity(value) {
+  return value;
+}
+function beforePaint(cb = noop) {
+  const raf = requestAnimationFrame(cb);
+  return () => cancelAnimationFrame(raf);
+}
+function afterPaint(cb = noop) {
+  let raf = requestAnimationFrame(() => {
+    raf = requestAnimationFrame(cb);
+  });
+  return () => cancelAnimationFrame(raf);
+}
+function invariant(condition, message) {
+  if (condition)
+    return;
+  if (typeof message !== "string")
+    throw new Error("Invariant failed");
+  throw new Error(message);
+}
+function getKeys(obj) {
+  return Object.keys(obj);
+}
+function defaultValue(...values) {
+  for (const value of values) {
+    if (value !== void 0)
+      return value;
+  }
+  return void 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.noop = noop; exports.shallowEqual = shallowEqual; exports.applyState = applyState; exports.isObject = isObject; exports.isEmpty = isEmpty; exports.isInteger = isInteger; exports.hasOwnProperty = hasOwnProperty; exports.chain = chain; exports.cx = cx; exports.normalizeString = normalizeString; exports.omit = omit; exports.pick = pick; exports.identity = identity; exports.beforePaint = beforePaint; exports.afterPaint = afterPaint; exports.invariant = invariant; exports.getKeys = getKeys; exports.defaultValue = defaultValue;

package/cjs/__chunks/7ZXWQTAY.cjs

@@ -0,0 +1,71 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _3BBA3Z5Gcjs = require('./3BBA3Z5G.cjs');
+
+
+var _5D5Y5EI4cjs = require('./5D5Y5EI4.cjs');
+
+// src/disclosure/disclosure-store.ts
+function createDisclosureStore(props = {}) {
+  const syncState = _optionalChain([props, 'access', _ => _.store, 'optionalAccess', _2 => _2.getState, 'call', _3 => _3()]);
+  const open = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.open,
+    _optionalChain([syncState, 'optionalAccess', _4 => _4.open]),
+    props.defaultOpen,
+    false
+  );
+  const animated = _5D5Y5EI4cjs.defaultValue.call(void 0, props.animated, _optionalChain([syncState, 'optionalAccess', _5 => _5.animated]), false);
+  const initialState = {
+    open,
+    animated,
+    animating: !!animated && open,
+    mounted: open,
+    contentElement: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _6 => _6.contentElement]), null),
+    disclosureElement: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _7 => _7.disclosureElement]), null)
+  };
+  const disclosure = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, props.store);
+  disclosure.setup(
+    () => disclosure.sync(
+      (state) => {
+        if (state.animated)
+          return;
+        disclosure.setState("animating", false);
+      },
+      ["animated", "animating"]
+    )
+  );
+  disclosure.setup(
+    () => disclosure.sync(
+      (state, prev) => {
+        if (!state.animated)
+          return;
+        const mounting = state === prev;
+        const animating = mounting ? state.open : state.open !== prev.open;
+        disclosure.setState("animating", animating);
+      },
+      ["open", "animated"]
+    )
+  );
+  disclosure.setup(
+    () => disclosure.sync(
+      (state) => {
+        disclosure.setState("mounted", state.open || state.animating);
+      },
+      ["open", "animating"]
+    )
+  );
+  return {
+    ...disclosure,
+    setOpen: (value) => disclosure.setState("open", value),
+    show: () => disclosure.setState("open", true),
+    hide: () => disclosure.setState("open", false),
+    toggle: () => disclosure.setState("open", (open2) => !open2),
+    stopAnimation: () => disclosure.setState("animating", false),
+    setContentElement: (value) => disclosure.setState("contentElement", value),
+    setDisclosureElement: (value) => disclosure.setState("disclosureElement", value)
+  };
+}
+
+
+
+exports.createDisclosureStore = createDisclosureStore;

package/cjs/__chunks/AZVDLKO3.cjs

@@ -0,0 +1,286 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _NX5OHIMMcjs = require('./NX5OHIMM.cjs');
+
+
+var _3BBA3Z5Gcjs = require('./3BBA3Z5G.cjs');
+
+
+var _5D5Y5EI4cjs = require('./5D5Y5EI4.cjs');
+
+
+
+var _GDZQUFNPcjs = require('./GDZQUFNP.cjs');
+
+// src/composite/composite-store.ts
+var NULL_ITEM = { id: null };
+function findFirstEnabledItem(items, excludeId) {
+  return items.find((item) => {
+    if (excludeId) {
+      return !item.disabled && item.id !== excludeId;
+    }
+    return !item.disabled;
+  });
+}
+function getEnabledItems(items, excludeId) {
+  return items.filter((item) => {
+    if (excludeId) {
+      return !item.disabled && item.id !== excludeId;
+    }
+    return !item.disabled;
+  });
+}
+function getOppositeOrientation(orientation) {
+  if (orientation === "vertical")
+    return "horizontal";
+  if (orientation === "horizontal")
+    return "vertical";
+  return;
+}
+function getItemsInRow(items, rowId) {
+  return items.filter((item) => item.rowId === rowId);
+}
+function flipItems(items, activeId, shouldInsertNullItem = false) {
+  const index = items.findIndex((item) => item.id === activeId);
+  return [
+    ...items.slice(index + 1),
+    ...shouldInsertNullItem ? [NULL_ITEM] : [],
+    ...items.slice(0, index)
+  ];
+}
+function groupItemsByRows(items) {
+  const rows = [];
+  for (const item of items) {
+    const row = rows.find((currentRow) => _optionalChain([currentRow, 'access', _ => _[0], 'optionalAccess', _2 => _2.rowId]) === item.rowId);
+    if (row) {
+      row.push(item);
+    } else {
+      rows.push([item]);
+    }
+  }
+  return rows;
+}
+function getMaxRowLength(array) {
+  let maxLength = 0;
+  for (const { length } of array) {
+    if (length > maxLength) {
+      maxLength = length;
+    }
+  }
+  return maxLength;
+}
+function createEmptyItem(rowId) {
+  return {
+    id: "__EMPTY_ITEM__",
+    disabled: true,
+    rowId
+  };
+}
+function normalizeRows(rows, activeId, focusShift) {
+  const maxLength = getMaxRowLength(rows);
+  for (const row of rows) {
+    for (let i = 0; i < maxLength; i += 1) {
+      const item = row[i];
+      if (!item || focusShift && item.disabled) {
+        const isFirst = i === 0;
+        const previousItem = isFirst && focusShift ? findFirstEnabledItem(row) : row[i - 1];
+        row[i] = previousItem && activeId !== previousItem.id && focusShift ? previousItem : createEmptyItem(_optionalChain([previousItem, 'optionalAccess', _3 => _3.rowId]));
+      }
+    }
+  }
+  return rows;
+}
+function verticalizeItems(items) {
+  const rows = groupItemsByRows(items);
+  const maxLength = getMaxRowLength(rows);
+  const verticalized = [];
+  for (let i = 0; i < maxLength; i += 1) {
+    for (const row of rows) {
+      const item = row[i];
+      if (item) {
+        verticalized.push({
+          ...item,
+          // If there's no rowId, it means that it's not a grid composite, but
+          // a single row instead. So, instead of verticalizing it, that is,
+          // assigning a different rowId based on the column index, we keep it
+          // undefined so they will be part of the same row. This is useful
+          // when using up/down on one-dimensional composites.
+          rowId: item.rowId ? `${i}` : void 0
+        });
+      }
+    }
+  }
+  return verticalized;
+}
+function createCompositeStore(props = {}) {
+  const syncState = _optionalChain([props, 'access', _4 => _4.store, 'optionalAccess', _5 => _5.getState, 'call', _6 => _6()]);
+  const collection = _NX5OHIMMcjs.createCollectionStore.call(void 0, props);
+  const activeId = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.activeId,
+    _optionalChain([syncState, 'optionalAccess', _7 => _7.activeId]),
+    props.defaultActiveId
+  );
+  const initialState = {
+    ...collection.getState(),
+    activeId,
+    baseElement: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _8 => _8.baseElement]), null),
+    includesBaseElement: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.includesBaseElement,
+      _optionalChain([syncState, 'optionalAccess', _9 => _9.includesBaseElement]),
+      activeId === null
+    ),
+    moves: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _10 => _10.moves]), 0),
+    orientation: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.orientation,
+      _optionalChain([syncState, 'optionalAccess', _11 => _11.orientation]),
+      "both"
+    ),
+    rtl: _5D5Y5EI4cjs.defaultValue.call(void 0, props.rtl, _optionalChain([syncState, 'optionalAccess', _12 => _12.rtl]), false),
+    virtualFocus: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.virtualFocus,
+      _optionalChain([syncState, 'optionalAccess', _13 => _13.virtualFocus]),
+      false
+    ),
+    focusLoop: _5D5Y5EI4cjs.defaultValue.call(void 0, props.focusLoop, _optionalChain([syncState, 'optionalAccess', _14 => _14.focusLoop]), false),
+    focusWrap: _5D5Y5EI4cjs.defaultValue.call(void 0, props.focusWrap, _optionalChain([syncState, 'optionalAccess', _15 => _15.focusWrap]), false),
+    focusShift: _5D5Y5EI4cjs.defaultValue.call(void 0, props.focusShift, _optionalChain([syncState, 'optionalAccess', _16 => _16.focusShift]), false)
+  };
+  const composite = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, collection, props.store);
+  composite.setup(
+    () => composite.sync(
+      (state) => {
+        composite.setState("activeId", (activeId2) => {
+          if (activeId2 !== void 0)
+            return activeId2;
+          return _optionalChain([findFirstEnabledItem, 'call', _17 => _17(state.renderedItems), 'optionalAccess', _18 => _18.id]);
+        });
+      },
+      ["renderedItems", "activeId"]
+    )
+  );
+  const getNextId = (items, orientation, hasNullItem, skip) => {
+    const { activeId: activeId2, rtl, focusLoop, focusWrap, includesBaseElement } = composite.getState();
+    const isHorizontal = orientation !== "vertical";
+    const isRTL = rtl && isHorizontal;
+    const allItems = isRTL ? _GDZQUFNPcjs.reverseArray.call(void 0, items) : items;
+    if (activeId2 == null) {
+      return _optionalChain([findFirstEnabledItem, 'call', _19 => _19(allItems), 'optionalAccess', _20 => _20.id]);
+    }
+    const activeItem = allItems.find((item) => item.id === activeId2);
+    if (!activeItem) {
+      return _optionalChain([findFirstEnabledItem, 'call', _21 => _21(allItems), 'optionalAccess', _22 => _22.id]);
+    }
+    const isGrid = !!activeItem.rowId;
+    const activeIndex = allItems.indexOf(activeItem);
+    const nextItems = allItems.slice(activeIndex + 1);
+    const nextItemsInRow = getItemsInRow(nextItems, activeItem.rowId);
+    if (skip !== void 0) {
+      const nextEnabledItemsInRow = getEnabledItems(nextItemsInRow, activeId2);
+      const nextItem2 = nextEnabledItemsInRow.slice(skip)[0] || // If we can't find an item, just return the last one.
+      nextEnabledItemsInRow[nextEnabledItemsInRow.length - 1];
+      return _optionalChain([nextItem2, 'optionalAccess', _23 => _23.id]);
+    }
+    const oppositeOrientation = getOppositeOrientation(
+      // If it's a grid and orientation is not set, it's a next/previous call,
+      // which is inherently horizontal. up/down will call next with orientation
+      // set to vertical by default (see below on up/down methods).
+      isGrid ? orientation || "horizontal" : orientation
+    );
+    const canLoop = focusLoop && focusLoop !== oppositeOrientation;
+    const canWrap = isGrid && focusWrap && focusWrap !== oppositeOrientation;
+    hasNullItem = hasNullItem || !isGrid && canLoop && includesBaseElement;
+    if (canLoop) {
+      const loopItems = canWrap && !hasNullItem ? allItems : getItemsInRow(allItems, activeItem.rowId);
+      const sortedItems = flipItems(loopItems, activeId2, hasNullItem);
+      const nextItem2 = findFirstEnabledItem(sortedItems, activeId2);
+      return _optionalChain([nextItem2, 'optionalAccess', _24 => _24.id]);
+    }
+    if (canWrap) {
+      const nextItem2 = findFirstEnabledItem(
+        // We can use nextItems, which contains all the next items, including
+        // items from other rows, to wrap between rows. However, if there is a
+        // null item (the composite container), we'll only use the next items in
+        // the row. So moving next from the last item will focus on the
+        // composite container. On grid composites, horizontal navigation never
+        // focuses on the composite container, only vertical.
+        hasNullItem ? nextItemsInRow : nextItems,
+        activeId2
+      );
+      const nextId = hasNullItem ? _optionalChain([nextItem2, 'optionalAccess', _25 => _25.id]) || null : _optionalChain([nextItem2, 'optionalAccess', _26 => _26.id]);
+      return nextId;
+    }
+    const nextItem = findFirstEnabledItem(nextItemsInRow, activeId2);
+    if (!nextItem && hasNullItem) {
+      return null;
+    }
+    return _optionalChain([nextItem, 'optionalAccess', _27 => _27.id]);
+  };
+  return {
+    ...collection,
+    ...composite,
+    setBaseElement: (element) => composite.setState("baseElement", element),
+    setActiveId: (id) => composite.setState("activeId", id),
+    move: (id) => {
+      if (id === void 0)
+        return;
+      composite.setState("activeId", id);
+      composite.setState("moves", (moves) => moves + 1);
+    },
+    first: () => _optionalChain([findFirstEnabledItem, 'call', _28 => _28(composite.getState().renderedItems), 'optionalAccess', _29 => _29.id]),
+    last: () => _optionalChain([findFirstEnabledItem, 'call', _30 => _30(_GDZQUFNPcjs.reverseArray.call(void 0, composite.getState().renderedItems)), 'optionalAccess', _31 => _31.id]),
+    next: (skip) => {
+      const { renderedItems, orientation } = composite.getState();
+      return getNextId(renderedItems, orientation, false, skip);
+    },
+    previous: (skip) => {
+      const { renderedItems, orientation, includesBaseElement } = composite.getState();
+      const isGrid = !!_optionalChain([findFirstEnabledItem, 'call', _32 => _32(renderedItems), 'optionalAccess', _33 => _33.rowId]);
+      const hasNullItem = !isGrid && includesBaseElement;
+      return getNextId(
+        _GDZQUFNPcjs.reverseArray.call(void 0, renderedItems),
+        orientation,
+        hasNullItem,
+        skip
+      );
+    },
+    down: (skip) => {
+      const {
+        activeId: activeId2,
+        renderedItems,
+        focusShift,
+        focusLoop,
+        includesBaseElement
+      } = composite.getState();
+      const shouldShift = focusShift && !skip;
+      const verticalItems = verticalizeItems(
+        _GDZQUFNPcjs.flatten2DArray.call(void 0, 
+          normalizeRows(groupItemsByRows(renderedItems), activeId2, shouldShift)
+        )
+      );
+      const canLoop = focusLoop && focusLoop !== "horizontal";
+      const hasNullItem = canLoop && includesBaseElement;
+      return getNextId(verticalItems, "vertical", hasNullItem, skip);
+    },
+    up: (skip) => {
+      const { activeId: activeId2, renderedItems, focusShift, includesBaseElement } = composite.getState();
+      const shouldShift = focusShift && !skip;
+      const verticalItems = verticalizeItems(
+        _GDZQUFNPcjs.reverseArray.call(void 0, 
+          _GDZQUFNPcjs.flatten2DArray.call(void 0, 
+            normalizeRows(
+              groupItemsByRows(renderedItems),
+              activeId2,
+              shouldShift
+            )
+          )
+        )
+      );
+      const hasNullItem = includesBaseElement;
+      return getNextId(verticalItems, "vertical", hasNullItem, skip);
+    }
+  };
+}
+
+
+
+exports.createCompositeStore = createCompositeStore;

package/cjs/__chunks/EFEGT32M.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _7ZXWQTAYcjs = require('./7ZXWQTAY.cjs');
+
+// src/dialog/dialog-store.ts
+function createDialogStore(props = {}) {
+  return _7ZXWQTAYcjs.createDisclosureStore.call(void 0, props);
+}
+
+
+
+exports.createDialogStore = createDialogStore;

package/cjs/__chunks/EIDN2CWH.cjs

@@ -0,0 +1,57 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _3KP2MDG6cjs = require('./3KP2MDG6.cjs');
+
+
+var _3BBA3Z5Gcjs = require('./3BBA3Z5G.cjs');
+
+
+var _5D5Y5EI4cjs = require('./5D5Y5EI4.cjs');
+
+// src/hovercard/hovercard-store.ts
+function createHovercardStore(props = {}) {
+  const syncState = _optionalChain([props, 'access', _ => _.store, 'optionalAccess', _2 => _2.getState, 'call', _3 => _3()]);
+  const timeout = _5D5Y5EI4cjs.defaultValue.call(void 0, props.timeout, _optionalChain([syncState, 'optionalAccess', _4 => _4.timeout]), 500);
+  const popover = _3KP2MDG6cjs.createPopoverStore.call(void 0, {
+    ...props,
+    placement: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.placement,
+      _optionalChain([syncState, 'optionalAccess', _5 => _5.placement]),
+      "bottom"
+    )
+  });
+  const initialState = {
+    ...popover.getState(),
+    timeout,
+    showTimeout: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.showTimeout,
+      _optionalChain([syncState, 'optionalAccess', _6 => _6.showTimeout]),
+      timeout
+    ),
+    hideTimeout: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.hideTimeout,
+      _optionalChain([syncState, 'optionalAccess', _7 => _7.hideTimeout]),
+      timeout
+    ),
+    autoFocusOnShow: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _8 => _8.autoFocusOnShow]), false)
+  };
+  const hovercard = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, popover, props.store);
+  hovercard.setup(
+    () => hovercard.sync(
+      (state) => {
+        hovercard.setState("showTimeout", (value) => _nullishCoalesce(value, () => ( state.timeout)));
+        hovercard.setState("hideTimeout", (value) => _nullishCoalesce(value, () => ( state.timeout)));
+      },
+      ["timeout"]
+    )
+  );
+  return {
+    ...popover,
+    ...hovercard,
+    setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
+  };
+}
+
+
+
+exports.createHovercardStore = createHovercardStore;

package/cjs/__chunks/GDZQUFNP.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/array.ts
+function toArray(arg) {
+  if (Array.isArray(arg)) {
+    return arg;
+  }
+  return typeof arg !== "undefined" ? [arg] : [];
+}
+function addItemToArray(array, item, index = -1) {
+  if (!(index in array)) {
+    return [...array, item];
+  }
+  return [...array.slice(0, index), item, ...array.slice(index)];
+}
+function flatten2DArray(array) {
+  const flattened = [];
+  for (const row of array) {
+    flattened.push(...row);
+  }
+  return flattened;
+}
+function reverseArray(array) {
+  return array.slice().reverse();
+}
+
+
+
+
+
+
+exports.toArray = toArray; exports.addItemToArray = addItemToArray; exports.flatten2DArray = flatten2DArray; exports.reverseArray = reverseArray;