@makeswift/runtime 0.9.12 → 0.10.0

package/dist/types.es2.js

@@ -1,748 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-import { Element, Range, Editor, Text, Path, Transforms, Node, Point } from "slate";
-import { findBreakpointOverride } from "./state/breakpoints.es.js";
-import { bu as BlockType, bs as InlineType, bj as createRichTextV2Plugin, bt as RootBlockType, U as useStyle } from "./react-page.es.js";
-import "./actions.es.js";
-import { e as Select, u as unstable_IconRadioGroupIcon } from "./text-input.es.js";
-import isHotkey from "is-hotkey";
-import { cx } from "@emotion/css";
-import { jsx, Fragment } from "react/jsx-runtime";
-const ElementUtils = {
-  isRootBlock(node) {
-    return Element.isElement(node) && (Element.isElementType(node, BlockType.Paragraph) || Element.isElementType(node, BlockType.Heading1) || Element.isElementType(node, BlockType.Heading2) || Element.isElementType(node, BlockType.Heading3) || Element.isElementType(node, BlockType.Heading3) || Element.isElementType(node, BlockType.Heading4) || Element.isElementType(node, BlockType.Heading5) || Element.isElementType(node, BlockType.Heading6) || Element.isElementType(node, BlockType.BlockQuote) || Element.isElementType(node, BlockType.UnorderedList) || Element.isElementType(node, BlockType.OrderedList) || Element.isElementType(node, BlockType.Text) || Element.isElementType(node, BlockType.Default));
-  },
-  isBlock(node) {
-    return Element.isElement(node) && (this.isRootBlock(node) || Element.isElementType(node, BlockType.ListItem) || Element.isElementType(node, BlockType.ListItemChild));
-  },
-  isInline(node) {
-    return Element.isElementType(node, InlineType.Code) || Element.isElementType(node, InlineType.Link) || Element.isElementType(node, InlineType.SubScript) || Element.isElementType(node, InlineType.SuperScript);
-  },
-  isConvertibleToListTextNode(node) {
-    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
-  },
-  isList(node) {
-    return Element.isElementType(node, BlockType.OrderedList) || Element.isElementType(node, BlockType.UnorderedList);
-  },
-  isListItem(node) {
-    return Element.isElementType(node, BlockType.ListItem);
-  },
-  isListItemChild(node) {
-    return Element.isElementType(node, BlockType.ListItemChild);
-  },
-  createText() {
-    return { text: "" };
-  },
-  createParagraph() {
-    return {
-      children: [this.createText()],
-      type: BlockType.Paragraph
-    };
-  },
-  createList(type = BlockType.UnorderedList) {
-    return { children: [this.createText()], type };
-  },
-  createListItem() {
-    return {
-      children: [this.createListItemChild()],
-      type: BlockType.ListItem
-    };
-  },
-  createListItemChild() {
-    return {
-      children: [this.createText()],
-      type: BlockType.ListItemChild
-    };
-  }
-};
-function unhangRange(editor, range) {
-  let [start, end] = Range.edges(range);
-  if (start.offset !== 0 || end.offset !== 0 || Range.isCollapsed(range)) {
-    return range;
-  }
-  const endBlock = Editor.above(editor, {
-    at: end,
-    match: (n) => Element.isElement(n) && Editor.isBlock(editor, n)
-  });
-  const blockPath = endBlock ? endBlock[1] : [];
-  const first = Editor.start(editor, start);
-  const before = { anchor: first, focus: end };
-  let skip = true;
-  for (const [node, path] of Editor.nodes(editor, {
-    at: before,
-    match: Text.isText,
-    reverse: true
-  })) {
-    if (skip) {
-      skip = false;
-      continue;
-    }
-    if (node.text !== "" || Path.isBefore(path, blockPath)) {
-      end = { path, offset: node.text.length };
-      break;
-    }
-  }
-  return { anchor: start, focus: end };
-}
-function getSelection(editor) {
-  if (editor.selection)
-    return unhangRange(editor, editor.selection);
-  return {
-    anchor: Editor.start(editor, []),
-    focus: Editor.end(editor, [])
-  };
-}
-function getBlocksInSelection(editor) {
-  return Array.from(Editor.nodes(editor, {
-    at: getSelection(editor),
-    match: (node) => ElementUtils.isRootBlock(node)
-  })).filter((entry) => ElementUtils.isRootBlock(entry[0]));
-}
-function getActiveBlockType(editor) {
-  var _a;
-  const rootBlocks = getBlocksInSelection(editor).map(([node]) => node.type);
-  return rootBlocks.reduce((a, b) => a === b ? b : null, (_a = rootBlocks.at(0)) != null ? _a : null);
-}
-function setBlockKeyForDevice(editor, breakpoints, deviceId, key, value, options) {
-  var _a, _b;
-  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
-  if (!at)
-    return;
-  const rootElements = getBlocksInSelection(editor);
-  for (const [node, path] of rootElements) {
-    if (ElementUtils.isBlock(node)) {
-      const deviceValues = (_b = node[key]) != null ? _b : [];
-      const currentDeviceValue = findBreakpointOverride(breakpoints, deviceValues, deviceId, (v) => v);
-      const nextDeviceValue = __spreadProps(__spreadValues({}, currentDeviceValue), {
-        deviceId,
-        value
-      });
-      Transforms.setNodes(editor, {
-        [key]: [...deviceValues.filter((v) => v.deviceId !== deviceId), nextDeviceValue]
-      }, { at: path });
-    }
-  }
-}
-function clearBlockKeyForDevice(editor, deviceId, key) {
-  var _a;
-  const rootElements = getBlocksInSelection(editor);
-  for (const [node, path] of rootElements) {
-    if (ElementUtils.isBlock(node)) {
-      const deviceOverrides = (_a = node[key]) != null ? _a : [];
-      Transforms.setNodes(editor, {
-        [key]: deviceOverrides.filter((v) => v.deviceId !== deviceId)
-      }, { at: path });
-    }
-  }
-}
-function wrapInline(editor, inline) {
-  Transforms.wrapNodes(editor, inline, {
-    at: getSelection(editor),
-    split: true
-  });
-}
-function unwrapInline(editor, type) {
-  Transforms.unwrapNodes(editor, {
-    match: (node) => ElementUtils.isInline(node) && node.type === type,
-    at: getSelection(editor)
-  });
-}
-const EditorUtils = {
-  getFirstAncestorList(editor, path) {
-    try {
-      const parentList = Editor.above(editor, {
-        at: path,
-        match: (node) => ElementUtils.isList(node)
-      });
-      return parentList != null ? parentList : null;
-    } catch (e) {
-      return null;
-    }
-  },
-  getFirstAncestorListItem(editor, path) {
-    try {
-      const parentListItem = Editor.above(editor, {
-        at: path,
-        match: (node) => ElementUtils.isListItem(node)
-      });
-      return parentListItem != null ? parentListItem : null;
-    } catch (e) {
-      return null;
-    }
-  }
-};
-const LIST_ITEM_CHILD_POSITION = 0;
-const LIST_ITEM_LIST_POSITION = 1;
-function filterForSubtreeRoots(entries) {
-  return entries.filter(([, nodePath]) => !Path.ancestors(nodePath).some((ancestor) => {
-    return entries.some(([, path]) => Path.equals(path, ancestor));
-  }));
-}
-function unwrapPath(editor, listItemPath) {
-  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
-  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
-  if (!parentList || listItemContainingParentList)
-    return;
-  Editor.withoutNormalizing(editor, () => {
-    const listItemTextPath = [...listItemPath, LIST_ITEM_CHILD_POSITION];
-    const listItemNestedListPath = [...listItemPath, LIST_ITEM_LIST_POSITION];
-    if (Node.has(editor, listItemNestedListPath)) {
-      Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath });
-      Transforms.liftNodes(editor, { at: listItemNestedListPath });
-      Transforms.liftNodes(editor, { at: Path.next(listItemPath) });
-    }
-    if (Node.has(editor, listItemTextPath)) {
-      Transforms.setNodes(editor, { type: BlockType.Paragraph }, {
-        at: listItemTextPath
-      });
-      Transforms.liftNodes(editor, { at: listItemTextPath });
-      Transforms.liftNodes(editor, { at: listItemPath });
-    }
-  });
-}
-function unwrapList(editor, options) {
-  var _a;
-  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
-  if (!at)
-    return;
-  const listItems = Array.from(Editor.nodes(editor, {
-    at,
-    match: (node) => {
-      return Element.isElement(node) && ElementUtils.isListItem(node);
-    }
-  }));
-  const subRoots = filterForSubtreeRoots(listItems);
-  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
-  refs.forEach((ref) => {
-    if (ref.current) {
-      unwrapPath(editor, ref.current);
-    }
-    ref.unref();
-  });
-}
-function wrapList(editor, options = { type: BlockType.UnorderedList }) {
-  var _a;
-  const at = (_a = options.at) != null ? _a : editor.selection;
-  if (!at)
-    return;
-  const nonListEntries = Array.from(Editor.nodes(editor, {
-    at,
-    match: (node) => {
-      return Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node);
-    }
-  }));
-  const refs = nonListEntries.map(([_, path]) => Editor.pathRef(editor, path));
-  refs.forEach((ref) => {
-    const path = ref.current;
-    if (path) {
-      Editor.withoutNormalizing(editor, () => {
-        Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
-          at: path
-        });
-        Transforms.wrapNodes(editor, ElementUtils.createListItem(), {
-          match: (node) => ElementUtils.isListItemChild(node),
-          at: path
-        });
-        Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {
-          at: path
-        });
-      });
-    }
-    ref.unref();
-  });
-}
-const LocationUtils = {
-  getStartPath(location) {
-    if (Range.isRange(location))
-      return Range.start(location).path;
-    if (Point.isPoint(location))
-      return location.path;
-    return location;
-  }
-};
-function getSelectedListItems(editor) {
-  var _a, _b;
-  if (!editor.selection)
-    return [];
-  const start = LocationUtils.getStartPath(editor.selection);
-  const listItems = Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => ElementUtils.isListItem(node)
-  });
-  const firstAncestorPath = (_b = (_a = EditorUtils.getFirstAncestorListItem(editor, start)) == null ? void 0 : _a[1]) != null ? _b : [];
-  return Array.from(listItems).filter((node) => Path.isDescendant(start, node[1]) ? Path.equals(node[1], firstAncestorPath) : !Path.isAfter(start, node[1]));
-}
-function indentPath(editor, path) {
-  const parent = Node.parent(editor, path);
-  if (!path || !Path.hasPrevious(path) || !ElementUtils.isList(parent))
-    return;
-  const previosPath = Path.previous(path);
-  const previousChildListPath = [...previosPath, LIST_ITEM_LIST_POSITION];
-  const previousHasChildList = Node.has(editor, previousChildListPath);
-  Editor.withoutNormalizing(editor, () => {
-    if (!previousHasChildList) {
-      Transforms.insertNodes(editor, ElementUtils.createList(parent.type), {
-        at: previousChildListPath
-      });
-    }
-    const previousChildList = Node.get(editor, previousChildListPath);
-    if (ElementUtils.isList(previousChildList)) {
-      const index = previousHasChildList ? previousChildList.children.length : 0;
-      Transforms.moveNodes(editor, {
-        at: path,
-        to: [...previousChildListPath, index]
-      });
-    }
-  });
-}
-function indent(editor) {
-  if (!editor.selection)
-    return;
-  const listItems = getSelectedListItems(editor);
-  const subRoots = filterForSubtreeRoots(listItems);
-  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
-  refs.forEach((ref) => {
-    if (ref.current) {
-      indentPath(editor, ref.current);
-    }
-    ref.unref();
-  });
-}
-function dedentPath(editor, listItemPath) {
-  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
-  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
-  if (!parentList || !listItemContainingParentList)
-    return;
-  const [parentListNode, parentListPath] = parentList;
-  const [_, listItemContainingParentListPath] = listItemContainingParentList;
-  const listItemPosition = listItemPath[listItemPath.length - 1];
-  const previousSiblings = parentListNode.children.slice(0, listItemPosition);
-  const nextSiblings = parentListNode.children.slice(listItemPosition + 1);
-  Editor.withoutNormalizing(editor, () => {
-    nextSiblings.forEach(() => {
-      const nextSiblingPath = [...parentListPath, listItemPosition + 1];
-      indentPath(editor, nextSiblingPath);
-    });
-    Transforms.moveNodes(editor, {
-      at: listItemPath,
-      to: Path.next(listItemContainingParentListPath)
-    });
-    if (previousSiblings.length === 0) {
-      Transforms.removeNodes(editor, { at: parentListPath });
-    }
-  });
-}
-function dedent(editor) {
-  if (!editor.selection)
-    return;
-  const listItems = getSelectedListItems(editor);
-  const subRoots = filterForSubtreeRoots(listItems);
-  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
-  refs.forEach((ref) => {
-    if (ref.current) {
-      dedentPath(editor, ref.current);
-    }
-    ref.unref();
-  });
-}
-function toggleList(editor, options = { type: BlockType.UnorderedList }) {
-  var _a;
-  const at = (_a = options.at) != null ? _a : editor.selection;
-  if (at == null)
-    return;
-  const start = LocationUtils.getStartPath(at);
-  const ancestorPath = Path.ancestors(start).at(1);
-  if (!ancestorPath || !Node.has(editor, ancestorPath))
-    return;
-  const ancestor = Node.get(editor, ancestorPath);
-  if (!ElementUtils.isList(ancestor)) {
-    return wrapList(editor, { type: options.type, at });
-  }
-  if (ancestor.type === options.type) {
-    unwrapList(editor, { at });
-  } else {
-    Transforms.setNodes(editor, { type: options.type }, { at: ancestorPath });
-  }
-}
-const BlockActions = {
-  setBlockKeyForDevice,
-  clearBlockKeyForDevice,
-  wrapInline,
-  unwrapInline
-};
-const ListActions = {
-  unwrapList,
-  wrapList,
-  indent,
-  dedent,
-  toggleList
-};
-function onKeyDown(e, editor) {
-  if (!editor.selection || Array.from(Editor.nodes(editor, {
-    match: (node) => ElementUtils.isListItem(node)
-  })).length === 0)
-    return;
-  if (isHotkey("shift+tab", e)) {
-    e.preventDefault();
-    ListActions.dedent(editor);
-  }
-  if (isHotkey("tab", e)) {
-    e.preventDefault();
-    ListActions.indent(editor);
-  }
-  if (isHotkey("backspace", e)) {
-    if (!editor.selection)
-      return;
-    if (Range.isExpanded(editor.selection))
-      return;
-    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
-    if (editor.selection.anchor.offset === 0 && listItem) {
-      e.preventDefault();
-      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
-      const list = EditorUtils.getFirstAncestorList(editor, listItem[1]);
-      if (parentListItem) {
-        ListActions.dedent(editor);
-      } else if (list) {
-        ListActions.unwrapList(editor);
-      }
-      return;
-    }
-  }
-  if (isHotkey("enter", e)) {
-    e.preventDefault();
-    if (!editor.selection)
-      return;
-    if (Range.isExpanded(editor.selection)) {
-      Transforms.delete(editor);
-      return;
-    }
-    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
-    if (editor.selection.anchor.offset === 0 && listItem && Editor.string(editor, listItem[1]) === "") {
-      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
-      if (parentListItem) {
-        ListActions.dedent(editor);
-      } else {
-        ListActions.unwrapList(editor);
-      }
-      return;
-    }
-    Transforms.splitNodes(editor, {
-      at: editor.selection,
-      always: true,
-      match: (node) => ElementUtils.isListItem(node)
-    });
-  }
-  if (isHotkey("shift+enter", e)) {
-    e.preventDefault();
-    editor.insertText("\n");
-  }
-}
-function withBlock(editor) {
-  const {
-    normalizeNode
-  } = editor;
-  editor.isInline = (entry) => {
-    return ElementUtils.isInline(entry);
-  };
-  editor.normalizeNode = (entry) => {
-    var _a;
-    const [normalizationNode, normalizationPath] = entry;
-    if (ElementUtils.isBlock(normalizationNode) && ((_a = normalizationNode == null ? void 0 : normalizationNode.textAlign) == null ? void 0 : _a.length) == 0) {
-      Transforms.unsetNodes(editor, "textAlign", {
-        at: normalizationPath
-      });
-      return;
-    }
-    if (ElementUtils.isListItem(normalizationNode)) {
-      const pathToListItemText = [...normalizationPath, LIST_ITEM_CHILD_POSITION];
-      if (Node.has(editor, pathToListItemText)) {
-        const nodeInListItemTextPosition = Node.get(editor, pathToListItemText);
-        if (ElementUtils.isRootBlock(nodeInListItemTextPosition)) {
-          Transforms.setNodes(editor, {
-            type: BlockType.ListItemChild
-          }, {
-            at: pathToListItemText
-          });
-          return;
-        }
-      } else {
-        Transforms.insertNodes(editor, ElementUtils.createListItem(), {
-          at: pathToListItemText
-        });
-        return;
-      }
-    }
-    if (!Text.isText(normalizationNode)) {
-      const mergeableChildren = Array.from(Node.children(editor, normalizationPath)).map((child, index, children) => {
-        const potentialNodeToBeMerged = children.at(index + 1);
-        if (!potentialNodeToBeMerged || !ElementUtils.isList(potentialNodeToBeMerged[0]) || !ElementUtils.isList(child[0]) || potentialNodeToBeMerged[0].type !== child[0].type) {
-          return null;
-        }
-        return [Editor.pathRef(editor, child[1]), Editor.pathRef(editor, potentialNodeToBeMerged[1])];
-      }).filter((mergeableNodes) => Boolean(mergeableNodes));
-      if (mergeableChildren.length !== 0) {
-        mergeableChildren.reverse().forEach(([nodePathRef, nodeToBeMergedPathRef]) => {
-          const nodePath = nodePathRef.current;
-          const nodeToBeMergedPath = nodeToBeMergedPathRef.current;
-          if (nodePath == null || nodeToBeMergedPath == null)
-            return;
-          const nodeChildren = Array.from(Node.children(editor, nodePath));
-          const childrenToBeMerged = Array.from(Node.children(editor, nodeToBeMergedPath));
-          Editor.withoutNormalizing(editor, () => {
-            childrenToBeMerged.reverse().forEach(([_, childPath]) => {
-              Transforms.moveNodes(editor, {
-                at: childPath,
-                to: [...nodePath, nodeChildren.length]
-              });
-            });
-            Transforms.removeNodes(editor, {
-              at: nodeToBeMergedPath
-            });
-          });
-          nodePathRef.unref();
-          nodeToBeMergedPathRef.unref();
-        });
-        return;
-      }
-    }
-    normalizeNode(entry);
-  };
-  return editor;
-}
-const definition = Select({
-  label: "Block",
-  labelOrientation: "horizontal",
-  options: [{
-    value: BlockType.Paragraph,
-    label: "Paragraph"
-  }, {
-    value: BlockType.Heading1,
-    label: "Heading 1"
-  }, {
-    value: BlockType.Heading2,
-    label: "Heading 2"
-  }, {
-    value: BlockType.Heading3,
-    label: "Heading 3"
-  }, {
-    value: BlockType.Heading4,
-    label: "Heading 4"
-  }, {
-    value: BlockType.Heading5,
-    label: "Heading 5"
-  }, {
-    value: BlockType.Heading6,
-    label: "Heading 6"
-  }, {
-    value: BlockType.UnorderedList,
-    label: "Bulleted list"
-  }, {
-    value: BlockType.OrderedList,
-    label: "Numbered list"
-  }, {
-    value: BlockType.BlockQuote,
-    label: "Quote"
-  }],
-  defaultValue: BlockType.Paragraph
-});
-function BlockPlugin() {
-  return createRichTextV2Plugin({
-    withPlugin: withBlock,
-    onKeyDown,
-    control: {
-      definition,
-      onChange: (editor, value) => {
-        const activeBlockType = getActiveBlockType(editor);
-        if (value === BlockType.UnorderedList || value === BlockType.OrderedList) {
-          ListActions.toggleList(editor, {
-            type: value,
-            at: getSelection(editor)
-          });
-        } else if (activeBlockType === value) {
-          Transforms.setNodes(editor, {
-            type: BlockType.Default
-          }, {
-            at: getSelection(editor)
-          });
-        } else {
-          ListActions.unwrapList(editor, {
-            at: getSelection(editor)
-          });
-          Transforms.setNodes(editor, {
-            type: value != null ? value : BlockType.Default
-          }, {
-            at: getSelection(editor)
-          });
-        }
-      },
-      getValue: (editor) => {
-        const activeBlock = getActiveBlockType(editor);
-        if (activeBlock === RootBlockType.Text || activeBlock === RootBlockType.Default)
-          return void 0;
-        return activeBlock;
-      }
-    },
-    renderElement: (renderElement) => (props) => /* @__PURE__ */ jsx(BlockPluginComponent, __spreadProps(__spreadValues({}, props), {
-      renderElement
-    }))
-  });
-}
-function BlockPluginComponent(_a) {
-  var _b = _a, {
-    renderElement
-  } = _b, props = __objRest(_b, [
-    "renderElement"
-  ]);
-  const blockStyles = [useStyle({
-    margin: 0
-  }), props.element.className];
-  const quoteStyles = useStyle({
-    padding: "0.5em 10px",
-    fontSize: "1.25em",
-    fontWeight: "300",
-    borderLeft: "5px solid rgba(0, 0, 0, 0.1)"
-  });
-  const unorderedListStyles = useStyle({
-    listStylePosition: "inside",
-    paddingInlineStart: "20px",
-    listStyleType: "disc",
-    ul: {
-      listStyleType: "circle"
-    },
-    "ul ul": {
-      listStyleType: "square"
-    }
-  });
-  const orderedListStyles = useStyle({
-    listStylePosition: "inside",
-    paddingInlineStart: "20px",
-    listStyleType: "decimal"
-  });
-  switch (props.element.type) {
-    case BlockType.Text:
-      return /* @__PURE__ */ jsx("span", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Default:
-    case BlockType.Paragraph:
-      return /* @__PURE__ */ jsx("p", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading1:
-      return /* @__PURE__ */ jsx("h1", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading2:
-      return /* @__PURE__ */ jsx("h2", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading3:
-      return /* @__PURE__ */ jsx("h3", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading4:
-      return /* @__PURE__ */ jsx("h4", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading5:
-      return /* @__PURE__ */ jsx("h5", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.Heading6:
-      return /* @__PURE__ */ jsx("h6", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.BlockQuote:
-      return /* @__PURE__ */ jsx("blockquote", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles, quoteStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.OrderedList:
-      return /* @__PURE__ */ jsx("ol", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles, orderedListStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.UnorderedList:
-      return /* @__PURE__ */ jsx("ul", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles, unorderedListStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.ListItem:
-      return /* @__PURE__ */ jsx("li", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    case BlockType.ListItemChild:
-      return /* @__PURE__ */ jsx("span", __spreadProps(__spreadValues({}, props.attributes), {
-        className: cx(...blockStyles),
-        children: renderElement(props)
-      }));
-    default:
-      return /* @__PURE__ */ jsx(Fragment, {
-        children: renderElement(props)
-      });
-  }
-}
-const supportedInlineOptions = [
-  {
-    icon: unstable_IconRadioGroupIcon.Superscript,
-    label: "Superscript",
-    value: "superscript"
-  },
-  {
-    icon: unstable_IconRadioGroupIcon.Subscript,
-    label: "Subscript",
-    value: "subscript"
-  },
-  {
-    icon: unstable_IconRadioGroupIcon.Code,
-    label: "Code",
-    value: "code"
-  }
-];
-function isSupportedInlineType(inline) {
-  return supportedInlineOptions.findIndex((option) => option.value === inline) !== -1;
-}
-function isSupportedInlineEntry(entry) {
-  const node = entry[0];
-  return ElementUtils.isInline(node) && supportedInlineOptions.findIndex((option) => option.value === node.type) !== -1;
-}
-export { BlockActions as B, ElementUtils as E, ListActions as L, isSupportedInlineEntry as a, withBlock as b, BlockPlugin as c, filterForSubtreeRoots as f, getSelection as g, isSupportedInlineType as i, onKeyDown as o, supportedInlineOptions as s, unwrapInline as u, wrapInline as w };
-//# sourceMappingURL=types.es2.js.map