alinea 1.7.0 → 2.0.0-preview.1

package/dist/chunks/chunk-AC4U3IMS.js

@@ -0,0 +1,205 @@
+// node_modules/react-stately/dist/private/dnd/useDraggableCollectionState.mjs
+import { useState as $16cpX$useState, useRef as $16cpX$useRef } from "react";
+function $b2d15a2f12e80349$export$29efd034f1d79f81(props) {
+  let { getItems, isDisabled, collection, selectionManager, onDragStart, onDragMove, onDragEnd, preview, getAllowedDropOperations } = props;
+  let [, setDragging] = (0, $16cpX$useState)(false);
+  let draggingKeys = (0, $16cpX$useRef)(/* @__PURE__ */ new Set());
+  let draggedKey = (0, $16cpX$useRef)(null);
+  let getKeys = (key) => {
+    let keys = /* @__PURE__ */ new Set();
+    if (selectionManager.isSelected(key)) for (let currentKey of selectionManager.selectedKeys) {
+      let node = collection.getItem(currentKey);
+      if (node) {
+        let isChild = false;
+        let parentKey = node.parentKey;
+        while (parentKey != null) {
+          if (selectionManager.selectedKeys.has(parentKey)) {
+            isChild = true;
+            break;
+          }
+          let parentNode = collection.getItem(parentKey);
+          parentKey = parentNode ? parentNode.parentKey : null;
+        }
+        if (!isChild) keys.add(currentKey);
+      }
+    }
+    else keys.add(key);
+    return keys;
+  };
+  return {
+    collection,
+    selectionManager,
+    get draggedKey() {
+      return draggedKey.current;
+    },
+    get draggingKeys() {
+      return draggingKeys.current;
+    },
+    isDragging(key) {
+      return draggingKeys.current.has(key);
+    },
+    getKeysForDrag: getKeys,
+    getItems(key) {
+      let keys = getKeys(key);
+      let items = [];
+      for (let key2 of keys) {
+        let value = collection.getItem(key2)?.value;
+        if (value != null) items.push(value);
+      }
+      return getItems(getKeys(key), items);
+    },
+    isDisabled,
+    preview,
+    getAllowedDropOperations,
+    startDrag(key, event) {
+      let keys = getKeys(key);
+      draggingKeys.current = keys;
+      draggedKey.current = key;
+      selectionManager.setFocused(false);
+      setDragging(true);
+      if (typeof onDragStart === "function") onDragStart({
+        ...event,
+        keys
+      });
+    },
+    moveDrag(event) {
+      if (typeof onDragMove === "function") onDragMove({
+        ...event,
+        keys: draggingKeys.current
+      });
+    },
+    endDrag(event) {
+      let { isInternal } = event;
+      if (typeof onDragEnd === "function") onDragEnd({
+        ...event,
+        keys: draggingKeys.current,
+        isInternal
+      });
+      draggingKeys.current = /* @__PURE__ */ new Set();
+      draggedKey.current = null;
+      setDragging(false);
+    }
+  };
+}
+
+// node_modules/react-stately/dist/private/dnd/useDroppableCollectionState.mjs
+import { useState as $5gqtb$useState, useRef as $5gqtb$useRef, useCallback as $5gqtb$useCallback } from "react";
+function $e279703d7ed26e75$export$926850f6ecef79d0(props) {
+  let { acceptedDragTypes = "all", isDisabled, onInsert, onRootDrop, onItemDrop, onReorder, onMove, shouldAcceptItemDrop, collection, selectionManager, onDropEnter, getDropOperation, onDrop } = props;
+  let [target, setTarget] = (0, $5gqtb$useState)(null);
+  let targetRef = (0, $5gqtb$useRef)(null);
+  let getOppositeTarget = (target2) => {
+    if (target2.dropPosition === "before") {
+      let node = collection.getItem(target2.key);
+      return node && node.prevKey != null ? {
+        type: "item",
+        key: node.prevKey,
+        dropPosition: "after"
+      } : null;
+    } else if (target2.dropPosition === "after") {
+      let node = collection.getItem(target2.key);
+      return node && node.nextKey != null ? {
+        type: "item",
+        key: node.nextKey,
+        dropPosition: "before"
+      } : null;
+    }
+    return null;
+  };
+  let defaultGetDropOperation = (0, $5gqtb$useCallback)((e) => {
+    let { target: target2, types, allowedOperations, isInternal, draggingKeys } = e;
+    if (isDisabled || !target2) return "cancel";
+    if (acceptedDragTypes === "all" || acceptedDragTypes.some((type) => types.has(type))) {
+      let isValidInsert = onInsert && target2.type === "item" && !isInternal && (target2.dropPosition === "before" || target2.dropPosition === "after");
+      let isValidReorder = onReorder && target2.type === "item" && isInternal && (target2.dropPosition === "before" || target2.dropPosition === "after") && $e279703d7ed26e75$var$isDraggingWithinParent(collection, target2, draggingKeys);
+      let isItemDropAllowed = target2.type !== "item" || target2.dropPosition !== "on" || !shouldAcceptItemDrop || shouldAcceptItemDrop(target2, types);
+      let isValidMove = onMove && target2.type === "item" && isInternal && isItemDropAllowed;
+      let isValidRootDrop = onRootDrop && target2.type === "root" && !isInternal;
+      let isValidOnItemDrop = onItemDrop && target2.type === "item" && target2.dropPosition === "on" && !(isInternal && target2.key != null && draggingKeys.has(target2.key)) && isItemDropAllowed;
+      if (onDrop || isValidInsert || isValidReorder || isValidMove || isValidRootDrop || isValidOnItemDrop) {
+        if (getDropOperation) return getDropOperation(target2, types, allowedOperations);
+        else return allowedOperations[0];
+      }
+    }
+    return "cancel";
+  }, [
+    isDisabled,
+    collection,
+    acceptedDragTypes,
+    getDropOperation,
+    onInsert,
+    onRootDrop,
+    onItemDrop,
+    shouldAcceptItemDrop,
+    onReorder,
+    onMove,
+    onDrop
+  ]);
+  return {
+    collection,
+    selectionManager,
+    isDisabled,
+    target,
+    setTarget(newTarget) {
+      if (this.isDropTarget(newTarget)) return;
+      let target2 = targetRef.current;
+      if (target2 && typeof props.onDropExit === "function") props.onDropExit({
+        type: "dropexit",
+        x: 0,
+        y: 0,
+        target: target2
+      });
+      if (newTarget && typeof onDropEnter === "function") onDropEnter({
+        type: "dropenter",
+        x: 0,
+        y: 0,
+        target: newTarget
+      });
+      targetRef.current = newTarget ?? null;
+      setTarget(newTarget ?? null);
+    },
+    isDropTarget(dropTarget) {
+      let target2 = targetRef.current;
+      if (!target2 || !dropTarget) return false;
+      if ($e279703d7ed26e75$var$isEqualDropTarget(dropTarget, target2)) return true;
+      if (dropTarget?.type === "item" && target2?.type === "item" && dropTarget.key !== target2.key && dropTarget.dropPosition !== target2.dropPosition && dropTarget.dropPosition !== "on" && target2.dropPosition !== "on") return $e279703d7ed26e75$var$isEqualDropTarget(getOppositeTarget(dropTarget), target2) || $e279703d7ed26e75$var$isEqualDropTarget(dropTarget, getOppositeTarget(target2));
+      return false;
+    },
+    getDropOperation(e) {
+      let { target: target2, isInternal, draggingKeys } = e;
+      if (isInternal && target2.type === "item" && draggingKeys.size > 0) {
+        if (draggingKeys.has(target2.key) && target2.dropPosition === "on") return "cancel";
+        let currentKey = target2.key;
+        while (currentKey != null) {
+          let item = collection.getItem(currentKey);
+          let parentKey = item?.parentKey;
+          if (parentKey != null && draggingKeys.has(parentKey)) return "cancel";
+          currentKey = parentKey ?? null;
+        }
+      }
+      return defaultGetDropOperation(e);
+    }
+  };
+}
+function $e279703d7ed26e75$var$isEqualDropTarget(a, b) {
+  if (!a) return !b;
+  switch (a.type) {
+    case "root":
+      return b?.type === "root";
+    case "item":
+      return b?.type === "item" && b?.key === a.key && b?.dropPosition === a.dropPosition;
+  }
+}
+function $e279703d7ed26e75$var$isDraggingWithinParent(collection, target, draggingKeys) {
+  let targetNode = collection.getItem(target.key);
+  for (let key of draggingKeys) {
+    let node = collection.getItem(key);
+    if (node?.parentKey !== targetNode?.parentKey) return false;
+  }
+  return true;
+}
+
+export {
+  $b2d15a2f12e80349$export$29efd034f1d79f81,
+  $e279703d7ed26e75$export$926850f6ecef79d0
+};

package/dist/chunks/chunk-BYJRQTFR.js

@@ -0,0 +1,57 @@
+// node_modules/cookie-es/dist/index.mjs
+var NullObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+function parse(str, options) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  const obj = new NullObject();
+  const opt = options || {};
+  const dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) {
+      break;
+    }
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (opt?.filter && !opt?.filter(key)) {
+      index = endIdx + 1;
+      continue;
+    }
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34) {
+        val = val.slice(1, -1);
+      }
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function decode(str) {
+  return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+  try {
+    return decode2(str);
+  } catch {
+    return str;
+  }
+}
+
+export {
+  parse
+};

package/dist/chunks/chunk-CQ52GEHY.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunks/chunk-F36YGSHN.js

@@ -0,0 +1,335 @@
+// node_modules/comlink/dist/esm/comlink.mjs
+var proxyMarker = /* @__PURE__ */ Symbol("Comlink.proxy");
+var createEndpoint = /* @__PURE__ */ Symbol("Comlink.endpoint");
+var releaseProxy = /* @__PURE__ */ Symbol("Comlink.releaseProxy");
+var finalizer = /* @__PURE__ */ Symbol("Comlink.finalizer");
+var throwMarker = /* @__PURE__ */ Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+var throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+var transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+export {
+  expose,
+  wrap
+};
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/