@makeswift/runtime 0.13.1 → 0.14.1

package/dist/cjs/slate/BlockPlugin/unwrapList.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unwrapList_exports = {};
+__export(unwrapList_exports, {
+  unwrapList: () => unwrapList,
+  unwrapPath: () => unwrapPath
+});
+module.exports = __toCommonJS(unwrapList_exports);
+var import_slate = require("slate");
+var import_editor = require("../utils/editor");
+var import_constants = require("./constants");
+var import_filterForSubtreeRoots = require("./utils/filterForSubtreeRoots");
+var import_element = require("../utils/element");
+var import_types = require("../types");
+function unwrapPath(editor, listItemPath) {
+  const parentList = import_editor.EditorUtils.getFirstAncestorList(editor, listItemPath);
+  const listItemContainingParentList = import_editor.EditorUtils.getFirstAncestorListItem(editor, listItemPath);
+  if (!parentList || listItemContainingParentList)
+    return;
+  import_slate.Editor.withoutNormalizing(editor, () => {
+    const listItemTextPath = [...listItemPath, import_constants.LIST_ITEM_CHILD_POSITION];
+    const listItemNestedListPath = [...listItemPath, import_constants.LIST_ITEM_LIST_POSITION];
+    if (import_slate.Node.has(editor, listItemNestedListPath)) {
+      import_slate.Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath });
+      import_slate.Transforms.liftNodes(editor, { at: listItemNestedListPath });
+      import_slate.Transforms.liftNodes(editor, { at: import_slate.Path.next(listItemPath) });
+    }
+    if (import_slate.Node.has(editor, listItemTextPath)) {
+      import_slate.Transforms.setNodes(
+        editor,
+        { type: import_types.BlockType.Paragraph },
+        {
+          at: listItemTextPath
+        }
+      );
+      import_slate.Transforms.liftNodes(editor, { at: listItemTextPath });
+      import_slate.Transforms.liftNodes(editor, { at: listItemPath });
+    }
+  });
+}
+function unwrapList(editor, options) {
+  const at = options?.at ?? editor.selection;
+  if (!at)
+    return;
+  const listItems = Array.from(
+    import_slate.Editor.nodes(editor, {
+      at,
+      match: (node) => {
+        return import_slate.Element.isElement(node) && import_element.ElementUtils.isListItem(node);
+      }
+    })
+  );
+  const subRoots = (0, import_filterForSubtreeRoots.filterForSubtreeRoots)(listItems);
+  const refs = subRoots.map(([_, path]) => import_slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      unwrapPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unwrapList,
+  unwrapPath
+});
+//# sourceMappingURL=unwrapList.js.map

package/dist/cjs/slate/BlockPlugin/unwrapList.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/BlockPlugin/unwrapList.ts"],"sourcesContent":["import { Editor, Element, Transforms, Path, Node, Location, Span } from 'slate'\nimport { EditorUtils } from '../utils/editor'\nimport { LIST_ITEM_CHILD_POSITION, LIST_ITEM_LIST_POSITION } from './constants'\nimport { filterForSubtreeRoots } from './utils/filterForSubtreeRoots'\nimport { ElementUtils } from '../utils/element'\nimport { BlockType } from '../types'\n\nexport function unwrapPath(editor: Editor, listItemPath: Path) {\n  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath)\n  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath)\n  //if this is a nested item we don't want to unwrap it\n  if (!parentList || listItemContainingParentList) return\n\n  Editor.withoutNormalizing(editor, () => {\n    const listItemTextPath = [...listItemPath, LIST_ITEM_CHILD_POSITION]\n    const listItemNestedListPath = [...listItemPath, LIST_ITEM_LIST_POSITION]\n\n    if (Node.has(editor, listItemNestedListPath)) {\n      Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath })\n      Transforms.liftNodes(editor, { at: listItemNestedListPath })\n      Transforms.liftNodes(editor, { at: Path.next(listItemPath) })\n    }\n\n    if (Node.has(editor, listItemTextPath)) {\n      Transforms.setNodes(\n        editor,\n        { type: BlockType.Paragraph },\n        {\n          at: listItemTextPath,\n        },\n      )\n      Transforms.liftNodes(editor, { at: listItemTextPath })\n      Transforms.liftNodes(editor, { at: listItemPath })\n    }\n  })\n}\n\ntype UnwrapListOptions = {\n  at?: Location | Span\n}\n\nexport function unwrapList(editor: Editor, options?: UnwrapListOptions) {\n  const at = options?.at ?? editor.selection\n  if (!at) return\n\n  const listItems = Array.from(\n    Editor.nodes(editor, {\n      at,\n      match: node => {\n        return Element.isElement(node) && ElementUtils.isListItem(node)\n      },\n    }),\n  )\n  const subRoots = filterForSubtreeRoots(listItems)\n  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path))\n\n  refs.forEach(ref => {\n    if (ref.current) {\n      unwrapPath(editor, ref.current)\n    }\n    ref.unref()\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAwE;AACxE,oBAA4B;AAC5B,uBAAkE;AAClE,mCAAsC;AACtC,qBAA6B;AAC7B,mBAA0B;AAEnB,SAAS,WAAW,QAAgB,cAAoB;AAC7D,QAAM,aAAa,0BAAY,qBAAqB,QAAQ,YAAY;AACxE,QAAM,+BAA+B,0BAAY,yBAAyB,QAAQ,YAAY;AAE9F,MAAI,CAAC,cAAc;AAA8B;AAEjD,sBAAO,mBAAmB,QAAQ,MAAM;AACtC,UAAM,mBAAmB,CAAC,GAAG,cAAc,yCAAwB;AACnE,UAAM,yBAAyB,CAAC,GAAG,cAAc,wCAAuB;AAExE,QAAI,kBAAK,IAAI,QAAQ,sBAAsB,GAAG;AAC5C,8BAAW,SAAS,QAAQ,EAAE,MAAM,WAAW,CAAC,EAAE,KAAK,GAAG,EAAE,IAAI,uBAAuB,CAAC;AACxF,8BAAW,UAAU,QAAQ,EAAE,IAAI,uBAAuB,CAAC;AAC3D,8BAAW,UAAU,QAAQ,EAAE,IAAI,kBAAK,KAAK,YAAY,EAAE,CAAC;AAAA,IAC9D;AAEA,QAAI,kBAAK,IAAI,QAAQ,gBAAgB,GAAG;AACtC,8BAAW;AAAA,QACT;AAAA,QACA,EAAE,MAAM,uBAAU,UAAU;AAAA,QAC5B;AAAA,UACE,IAAI;AAAA,QACN;AAAA,MACF;AACA,8BAAW,UAAU,QAAQ,EAAE,IAAI,iBAAiB,CAAC;AACrD,8BAAW,UAAU,QAAQ,EAAE,IAAI,aAAa,CAAC;AAAA,IACnD;AAAA,EACF,CAAC;AACH;AAMO,SAAS,WAAW,QAAgB,SAA6B;AACtE,QAAM,KAAK,SAAS,MAAM,OAAO;AACjC,MAAI,CAAC;AAAI;AAET,QAAM,YAAY,MAAM;AAAA,IACtB,oBAAO,MAAM,QAAQ;AAAA,MACnB;AAAA,MACA,OAAO,UAAQ;AACb,eAAO,qBAAQ,UAAU,IAAI,KAAK,4BAAa,WAAW,IAAI;AAAA,MAChE;AAAA,IACF,CAAC;AAAA,EACH;AACA,QAAM,eAAW,oDAAsB,SAAS;AAChD,QAAM,OAAO,SAAS,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,oBAAO,QAAQ,QAAQ,IAAI,CAAC;AAErE,OAAK,QAAQ,SAAO;AAClB,QAAI,IAAI,SAAS;AACf,iBAAW,QAAQ,IAAI,OAAO;AAAA,IAChC;AACA,QAAI,MAAM;AAAA,EACZ,CAAC;AACH;","names":[]}

package/dist/cjs/slate/BlockPlugin/utils/filterForSubtreeRoots.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filterForSubtreeRoots_exports = {};
+__export(filterForSubtreeRoots_exports, {
+  filterForSubtreeRoots: () => filterForSubtreeRoots
+});
+module.exports = __toCommonJS(filterForSubtreeRoots_exports);
+var import_slate = require("slate");
+function filterForSubtreeRoots(entries) {
+  return entries.filter(
+    ([, nodePath]) => !import_slate.Path.ancestors(nodePath).some((ancestor) => {
+      return entries.some(([, path]) => import_slate.Path.equals(path, ancestor));
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterForSubtreeRoots
+});
+//# sourceMappingURL=filterForSubtreeRoots.js.map

package/dist/cjs/slate/BlockPlugin/utils/filterForSubtreeRoots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/slate/BlockPlugin/utils/filterForSubtreeRoots.ts"],"sourcesContent":["import type { Node, NodeEntry } from 'slate'\nimport { Path } from 'slate'\n\nexport function filterForSubtreeRoots(entries: NodeEntry<Node>[]): NodeEntry<Node>[] {\n  return entries.filter(\n    ([, nodePath]) =>\n      !Path.ancestors(nodePath).some(ancestor => {\n        return entries.some(([, path]) => Path.equals(path, ancestor))\n      }),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAAqB;AAEd,SAAS,sBAAsB,SAA+C;AACnF,SAAO,QAAQ;AAAA,IACb,CAAC,CAAC,EAAE,QAAQ,MACV,CAAC,kBAAK,UAAU,QAAQ,EAAE,KAAK,cAAY;AACzC,aAAO,QAAQ,KAAK,CAAC,CAAC,EAAE,IAAI,MAAM,kBAAK,OAAO,MAAM,QAAQ,CAAC;AAAA,IAC/D,CAAC;AAAA,EACL;AACF;","names":[]}

package/dist/cjs/slate/BlockPlugin/utils/getSelectedListItems.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getSelectedListItems_exports = {};
+__export(getSelectedListItems_exports, {
+  getSelectedListItems: () => getSelectedListItems
+});
+module.exports = __toCommonJS(getSelectedListItems_exports);
+var import_slate = require("slate");
+var import_editor = require("../../utils/editor");
+var import_element = require("../../utils/element");
+var import_location = require("./location");
+function getSelectedListItems(editor) {
+  if (!editor.selection)
+    return [];
+  const start = import_location.LocationUtils.getStartPath(editor.selection);
+  const listItems = import_slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => import_element.ElementUtils.isListItem(node)
+  });
+  const firstAncestorPath = import_editor.EditorUtils.getFirstAncestorListItem(editor, start)?.[1] ?? [];
+  return Array.from(listItems).filter(
+    (node) => import_slate.Path.isDescendant(start, node[1]) ? import_slate.Path.equals(node[1], firstAncestorPath) : !import_slate.Path.isAfter(start, node[1])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSelectedListItems
+});
+//# sourceMappingURL=getSelectedListItems.js.map

package/dist/cjs/slate/BlockPlugin/utils/getSelectedListItems.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/slate/BlockPlugin/utils/getSelectedListItems.ts"],"sourcesContent":["import type { Element, NodeEntry } from 'slate'\nimport { Editor, Path } from 'slate'\nimport { EditorUtils } from '../../utils/editor'\nimport { ElementUtils } from '../../utils/element'\nimport { LocationUtils } from './location'\n\nexport function getSelectedListItems(editor: Editor): NodeEntry<Element>[] {\n  if (!editor.selection) return []\n\n  const start = LocationUtils.getStartPath(editor.selection)\n  const listItems = Editor.nodes(editor, {\n    at: editor.selection,\n    match: node => ElementUtils.isListItem(node),\n  })\n  const firstAncestorPath = EditorUtils.getFirstAncestorListItem(editor, start)?.[1] ?? []\n\n  return Array.from(listItems).filter((node): node is NodeEntry<Element> =>\n    Path.isDescendant(start, node[1])\n      ? Path.equals(node[1], firstAncestorPath)\n      : !Path.isAfter(start, node[1]),\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA6B;AAC7B,oBAA4B;AAC5B,qBAA6B;AAC7B,sBAA8B;AAEvB,SAAS,qBAAqB,QAAsC;AACzE,MAAI,CAAC,OAAO;AAAW,WAAO,CAAC;AAE/B,QAAM,QAAQ,8BAAc,aAAa,OAAO,SAAS;AACzD,QAAM,YAAY,oBAAO,MAAM,QAAQ;AAAA,IACrC,IAAI,OAAO;AAAA,IACX,OAAO,UAAQ,4BAAa,WAAW,IAAI;AAAA,EAC7C,CAAC;AACD,QAAM,oBAAoB,0BAAY,yBAAyB,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC;AAEvF,SAAO,MAAM,KAAK,SAAS,EAAE;AAAA,IAAO,CAAC,SACnC,kBAAK,aAAa,OAAO,KAAK,CAAC,CAAC,IAC5B,kBAAK,OAAO,KAAK,CAAC,GAAG,iBAAiB,IACtC,CAAC,kBAAK,QAAQ,OAAO,KAAK,CAAC,CAAC;AAAA,EAClC;AACF;","names":[]}

package/dist/cjs/slate/BlockPlugin/utils/location.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var location_exports = {};
+__export(location_exports, {
+  LocationUtils: () => LocationUtils
+});
+module.exports = __toCommonJS(location_exports);
+var import_slate = require("slate");
+const LocationUtils = {
+  getStartPath(location) {
+    if (import_slate.Range.isRange(location))
+      return import_slate.Range.start(location).path;
+    if (import_slate.Point.isPoint(location))
+      return location.path;
+    return location;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocationUtils
+});
+//# sourceMappingURL=location.js.map

package/dist/cjs/slate/BlockPlugin/utils/location.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/slate/BlockPlugin/utils/location.ts"],"sourcesContent":["import { Range, Point, Path, Location } from 'slate'\n\nexport const LocationUtils = {\n  getStartPath(location: Location): Path {\n    if (Range.isRange(location)) return Range.start(location).path\n    if (Point.isPoint(location)) return location.path\n    return location\n  },\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA6C;AAEtC,MAAM,gBAAgB;AAAA,EAC3B,aAAa,UAA0B;AACrC,QAAI,mBAAM,QAAQ,QAAQ;AAAG,aAAO,mBAAM,MAAM,QAAQ,EAAE;AAC1D,QAAI,mBAAM,QAAQ,QAAQ;AAAG,aAAO,SAAS;AAC7C,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/cjs/slate/BlockPlugin/wrapInline.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wrapInline_exports = {};
+__export(wrapInline_exports, {
+  wrapInline: () => wrapInline
+});
+module.exports = __toCommonJS(wrapInline_exports);
+var import_slate = require("slate");
+var import_selectors = require("../selectors");
+function wrapInline(editor, inline) {
+  import_slate.Transforms.wrapNodes(editor, inline, {
+    at: (0, import_selectors.getSelection)(editor),
+    split: true
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapInline
+});
+//# sourceMappingURL=wrapInline.js.map

package/dist/cjs/slate/BlockPlugin/wrapInline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/BlockPlugin/wrapInline.ts"],"sourcesContent":["import { Editor, Transforms } from 'slate'\nimport { getSelection } from '../selectors'\nimport { Inline } from '../types'\n\nexport function wrapInline(editor: Editor, inline: Inline) {\n  Transforms.wrapNodes(editor, inline, {\n    at: getSelection(editor),\n    split: true,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAmC;AACnC,uBAA6B;AAGtB,SAAS,WAAW,QAAgB,QAAgB;AACzD,0BAAW,UAAU,QAAQ,QAAQ;AAAA,IACnC,QAAI,+BAAa,MAAM;AAAA,IACvB,OAAO;AAAA,EACT,CAAC;AACH;","names":[]}

package/dist/cjs/slate/BlockPlugin/wrapList.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wrapList_exports = {};
+__export(wrapList_exports, {
+  wrapList: () => wrapList
+});
+module.exports = __toCommonJS(wrapList_exports);
+var import_slate = require("slate");
+var import_element = require("../utils/element");
+var import_types = require("../types");
+function wrapList(editor, options = { type: import_types.BlockType.UnorderedList }) {
+  const at = options.at ?? editor.selection;
+  if (!at)
+    return;
+  const nonListEntries = Array.from(
+    import_slate.Editor.nodes(editor, {
+      at,
+      match: (node) => {
+        return import_slate.Element.isElement(node) && import_element.ElementUtils.isConvertibleToListTextNode(node);
+      }
+    })
+  );
+  const refs = nonListEntries.map(([_, path]) => import_slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    const path = ref.current;
+    if (path) {
+      import_slate.Editor.withoutNormalizing(editor, () => {
+        import_slate.Transforms.setNodes(
+          editor,
+          { type: import_types.BlockType.ListItemChild },
+          {
+            at: path
+          }
+        );
+        import_slate.Transforms.wrapNodes(editor, import_element.ElementUtils.createListItem(), {
+          match: (node) => import_element.ElementUtils.isListItemChild(node),
+          at: path
+        });
+        import_slate.Transforms.wrapNodes(editor, import_element.ElementUtils.createList(options.type), {
+          at: path
+        });
+      });
+    }
+    ref.unref();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapList
+});
+//# sourceMappingURL=wrapList.js.map

package/dist/cjs/slate/BlockPlugin/wrapList.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/BlockPlugin/wrapList.ts"],"sourcesContent":["import { Editor, Element, Location, Span, Transforms } from 'slate'\nimport { ElementUtils } from '../utils/element'\nimport { BlockType } from '../types'\n\ntype WrapListOptions = {\n  type: typeof BlockType.UnorderedList | typeof BlockType.OrderedList\n  at?: Location | Span\n}\n\nexport function wrapList(\n  editor: Editor,\n  options: WrapListOptions = { type: BlockType.UnorderedList },\n) {\n  const at = options.at ?? editor.selection\n  if (!at) return\n\n  const nonListEntries = Array.from(\n    Editor.nodes(editor, {\n      at,\n      match: node => {\n        return Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node)\n      },\n    }),\n  )\n\n  const refs = nonListEntries.map(([_, path]) => Editor.pathRef(editor, path))\n\n  refs.forEach(ref => {\n    const path = ref.current\n    if (path) {\n      Editor.withoutNormalizing(editor, () => {\n        Transforms.setNodes(\n          editor,\n          { type: BlockType.ListItemChild },\n          {\n            at: path,\n          },\n        )\n        Transforms.wrapNodes(editor, ElementUtils.createListItem(), {\n          match: node => ElementUtils.isListItemChild(node),\n          at: path,\n        })\n        Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {\n          at: path,\n        })\n      })\n    }\n    ref.unref()\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA4D;AAC5D,qBAA6B;AAC7B,mBAA0B;AAOnB,SAAS,SACd,QACA,UAA2B,EAAE,MAAM,uBAAU,cAAc,GAC3D;AACA,QAAM,KAAK,QAAQ,MAAM,OAAO;AAChC,MAAI,CAAC;AAAI;AAET,QAAM,iBAAiB,MAAM;AAAA,IAC3B,oBAAO,MAAM,QAAQ;AAAA,MACnB;AAAA,MACA,OAAO,UAAQ;AACb,eAAO,qBAAQ,UAAU,IAAI,KAAK,4BAAa,4BAA4B,IAAI;AAAA,MACjF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,eAAe,IAAI,CAAC,CAAC,GAAG,IAAI,MAAM,oBAAO,QAAQ,QAAQ,IAAI,CAAC;AAE3E,OAAK,QAAQ,SAAO;AAClB,UAAM,OAAO,IAAI;AACjB,QAAI,MAAM;AACR,0BAAO,mBAAmB,QAAQ,MAAM;AACtC,gCAAW;AAAA,UACT;AAAA,UACA,EAAE,MAAM,uBAAU,cAAc;AAAA,UAChC;AAAA,YACE,IAAI;AAAA,UACN;AAAA,QACF;AACA,gCAAW,UAAU,QAAQ,4BAAa,eAAe,GAAG;AAAA,UAC1D,OAAO,UAAQ,4BAAa,gBAAgB,IAAI;AAAA,UAChD,IAAI;AAAA,QACN,CAAC;AACD,gCAAW,UAAU,QAAQ,4BAAa,WAAW,QAAQ,IAAI,GAAG;AAAA,UAClE,IAAI;AAAA,QACN,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AACA,QAAI,MAAM;AAAA,EACZ,CAAC;AACH;","names":[]}

package/dist/cjs/slate/BuilderPlugin/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BuilderPlugin_exports = {};
+__export(BuilderPlugin_exports, {
+  withBuilder: () => withBuilder
+});
+module.exports = __toCommonJS(BuilderPlugin_exports);
+var import_slate = require("slate");
+var import_slate_react = require("slate-react");
+var import_element = require("../utils/element");
+function withBuilder(editor) {
+  editor.resetValue = function(value) {
+    const firstRootBlock = import_slate.Node.has(editor, [0]) && import_slate.Node.get(editor, [0]);
+    const textAlignOfFirstBlock = firstRootBlock && import_element.ElementUtils.isRootBlock(firstRootBlock) ? firstRootBlock.textAlign : void 0;
+    const typographyOfFirstText = Array.from(import_slate.Node.texts(editor)).at(0)?.[0].typography;
+    import_slate_react.ReactEditor.deselect(editor);
+    import_slate_react.ReactEditor.blur(editor);
+    editor.children = value;
+    editor.onChange();
+    if (typographyOfFirstText) {
+      import_slate.Transforms.setNodes(
+        editor,
+        { typography: typographyOfFirstText },
+        {
+          match: import_slate.Text.isText,
+          at: {
+            anchor: import_slate.Editor.start(editor, []),
+            focus: import_slate.Editor.end(editor, [])
+          }
+        }
+      );
+    }
+    if (textAlignOfFirstBlock) {
+      import_slate.Transforms.setNodes(
+        editor,
+        { textAlign: textAlignOfFirstBlock },
+        {
+          match: import_element.ElementUtils.isRootBlock,
+          at: {
+            anchor: import_slate.Editor.start(editor, []),
+            focus: import_slate.Editor.end(editor, [])
+          }
+        }
+      );
+    }
+  };
+  editor.deselectAndBlur = function() {
+    import_slate_react.ReactEditor.deselect(editor);
+    import_slate_react.ReactEditor.blur(editor);
+  };
+  editor.focusAndSelectAll = function() {
+    import_slate_react.ReactEditor.focus(editor);
+    import_slate.Transforms.select(editor, {
+      anchor: import_slate.Editor.start(editor, []),
+      focus: import_slate.Editor.end(editor, [])
+    });
+  };
+  return editor;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBuilder
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/slate/BuilderPlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/BuilderPlugin/index.ts"],"sourcesContent":["import { BaseEditor, Descendant, Editor, Transforms, Text, Node } from 'slate'\nimport { ReactEditor } from 'slate-react'\nimport { ElementUtils } from '../utils/element'\n\nexport interface BuilderEditor extends BaseEditor {\n  focusAndSelectAll: () => void\n  deselectAndBlur: () => void\n  resetValue: (value: Descendant[]) => void\n}\n\nexport function withBuilder(editor: Editor) {\n  editor.resetValue = function (value: Descendant[]) {\n    const firstRootBlock = Node.has(editor, [0]) && Node.get(editor, [0])\n    const textAlignOfFirstBlock =\n      firstRootBlock && ElementUtils.isRootBlock(firstRootBlock)\n        ? firstRootBlock.textAlign\n        : undefined\n    const typographyOfFirstText = Array.from(Node.texts(editor)).at(0)?.[0].typography\n\n    ReactEditor.deselect(editor)\n    ReactEditor.blur(editor)\n\n    editor.children = value\n    editor.onChange()\n\n    if (typographyOfFirstText) {\n      Transforms.setNodes(\n        editor,\n        { typography: typographyOfFirstText },\n        {\n          match: Text.isText,\n          at: {\n            anchor: Editor.start(editor, []),\n            focus: Editor.end(editor, []),\n          },\n        },\n      )\n    }\n    if (textAlignOfFirstBlock) {\n      Transforms.setNodes(\n        editor,\n        { textAlign: textAlignOfFirstBlock },\n        {\n          match: ElementUtils.isRootBlock,\n          at: {\n            anchor: Editor.start(editor, []),\n            focus: Editor.end(editor, []),\n          },\n        },\n      )\n    }\n  }\n  editor.deselectAndBlur = function () {\n    ReactEditor.deselect(editor)\n    ReactEditor.blur(editor)\n  }\n\n  editor.focusAndSelectAll = function () {\n    ReactEditor.focus(editor)\n    Transforms.select(editor, {\n      anchor: Editor.start(editor, []),\n      focus: Editor.end(editor, []),\n    })\n  }\n\n  return editor\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuE;AACvE,yBAA4B;AAC5B,qBAA6B;AAQtB,SAAS,YAAY,QAAgB;AAC1C,SAAO,aAAa,SAAU,OAAqB;AACjD,UAAM,iBAAiB,kBAAK,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,kBAAK,IAAI,QAAQ,CAAC,CAAC,CAAC;AACpE,UAAM,wBACJ,kBAAkB,4BAAa,YAAY,cAAc,IACrD,eAAe,YACf;AACN,UAAM,wBAAwB,MAAM,KAAK,kBAAK,MAAM,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE;AAExE,mCAAY,SAAS,MAAM;AAC3B,mCAAY,KAAK,MAAM;AAEvB,WAAO,WAAW;AAClB,WAAO,SAAS;AAEhB,QAAI,uBAAuB;AACzB,8BAAW;AAAA,QACT;AAAA,QACA,EAAE,YAAY,sBAAsB;AAAA,QACpC;AAAA,UACE,OAAO,kBAAK;AAAA,UACZ,IAAI;AAAA,YACF,QAAQ,oBAAO,MAAM,QAAQ,CAAC,CAAC;AAAA,YAC/B,OAAO,oBAAO,IAAI,QAAQ,CAAC,CAAC;AAAA,UAC9B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,QAAI,uBAAuB;AACzB,8BAAW;AAAA,QACT;AAAA,QACA,EAAE,WAAW,sBAAsB;AAAA,QACnC;AAAA,UACE,OAAO,4BAAa;AAAA,UACpB,IAAI;AAAA,YACF,QAAQ,oBAAO,MAAM,QAAQ,CAAC,CAAC;AAAA,YAC/B,OAAO,oBAAO,IAAI,QAAQ,CAAC,CAAC;AAAA,UAC9B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO,kBAAkB,WAAY;AACnC,mCAAY,SAAS,MAAM;AAC3B,mCAAY,KAAK,MAAM;AAAA,EACzB;AAEA,SAAO,oBAAoB,WAAY;AACrC,mCAAY,MAAM,MAAM;AACxB,4BAAW,OAAO,QAAQ;AAAA,MACxB,QAAQ,oBAAO,MAAM,QAAQ,CAAC,CAAC;AAAA,MAC/B,OAAO,oBAAO,IAAI,QAAQ,CAAC,CAAC;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/slate/InlineModePlugin/index.js

@@ -0,0 +1,93 @@
+"use strict";
+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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InlineModePlugin_exports = {};
+__export(InlineModePlugin_exports, {
+  InlineModePlugin: () => InlineModePlugin,
+  withInlineMode: () => withInlineMode
+});
+module.exports = __toCommonJS(InlineModePlugin_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_slate = require("slate");
+var import_is_hotkey = __toESM(require("is-hotkey"));
+var import_plugin = require("../../controls/rich-text-v2/plugin");
+var import_element = require("../utils/element");
+var import_types = require("../types");
+const BLOCK_ONE_PATH = [0];
+const BLOCK_TWO_PATH = [1];
+function withInlineMode(editor) {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    const [normalizationNode, normalizationPath] = entry;
+    if (import_slate.Path.equals(BLOCK_TWO_PATH, normalizationPath)) {
+      import_slate.Transforms.mergeNodes(editor, { at: BLOCK_TWO_PATH });
+      return;
+    }
+    if (import_slate.Path.isAncestor(BLOCK_ONE_PATH, normalizationPath) && import_element.ElementUtils.isBlock(normalizationNode)) {
+      import_slate.Transforms.unwrapNodes(editor, {
+        at: normalizationPath
+      });
+      return;
+    }
+    if (import_slate.Path.equals(BLOCK_ONE_PATH, normalizationPath)) {
+      import_slate.Transforms.setNodes(editor, { type: import_types.BlockType.Default }, { at: normalizationPath });
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+function InlineModePlugin() {
+  return (0, import_plugin.createRichTextV2Plugin)({
+    onKeyDown: (e) => {
+      if ((0, import_is_hotkey.default)("enter", e))
+        e.preventDefault();
+    },
+    withPlugin: withInlineMode,
+    renderElement: (renderElement) => (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineModePluginComponent, { ...props, renderElement })
+  });
+}
+const minWidth = `${"Write some text...".length}ch`;
+function InlineModePluginComponent({
+  renderElement,
+  ...props
+}) {
+  if (props.element.children.length === 1) {
+    const text = props.element.children[0];
+    if (import_slate.Text.isText(text) && text.text === "") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { display: "inline-block", minWidth }, ...props.attributes, children: renderElement(props) });
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { minWidth }, ...props.attributes, children: renderElement(props) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InlineModePlugin,
+  withInlineMode
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/slate/InlineModePlugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/InlineModePlugin/index.tsx"],"sourcesContent":["import { Editor, Path, Text, Transforms } from 'slate'\nimport { KeyboardEvent } from 'react'\nimport isHotkey from 'is-hotkey'\nimport { RenderElement, createRichTextV2Plugin } from '../../controls/rich-text-v2/plugin'\nimport { ElementUtils } from '../utils/element'\nimport { BlockType } from '../types'\nimport { RenderElementProps } from 'slate-react'\n\nconst BLOCK_ONE_PATH = [0]\nconst BLOCK_TWO_PATH = [1]\n\nexport function withInlineMode(editor: Editor): Editor {\n  const { normalizeNode } = editor\n  editor.normalizeNode = entry => {\n    const [normalizationNode, normalizationPath] = entry\n\n    /**\n     * Merge root nodes past the first one\n     */\n    if (Path.equals(BLOCK_TWO_PATH, normalizationPath)) {\n      Transforms.mergeNodes(editor, { at: BLOCK_TWO_PATH })\n      return\n    }\n    /**\n     * Unwrap non text nodes of first root node\n     */\n    if (\n      Path.isAncestor(BLOCK_ONE_PATH, normalizationPath) &&\n      ElementUtils.isBlock(normalizationNode)\n    ) {\n      Transforms.unwrapNodes(editor, {\n        at: normalizationPath,\n      })\n      return\n    }\n    /**\n     * Update type of root nodes to be `text-block`\n     */\n    if (Path.equals(BLOCK_ONE_PATH, normalizationPath)) {\n      Transforms.setNodes(editor, { type: BlockType.Default }, { at: normalizationPath })\n      return\n    }\n\n    normalizeNode(entry)\n  }\n\n  return editor\n}\n\nexport function InlineModePlugin() {\n  return createRichTextV2Plugin({\n    onKeyDown: (e: KeyboardEvent) => {\n      if (isHotkey('enter', e)) e.preventDefault()\n    },\n    withPlugin: withInlineMode,\n    renderElement: renderElement => props =>\n      <InlineModePluginComponent {...props} renderElement={renderElement} />,\n  })\n}\n\nconst minWidth = `${'Write some text...'.length}ch`\n\nfunction InlineModePluginComponent({\n  renderElement,\n  ...props\n}: RenderElementProps & { renderElement: RenderElement }) {\n  if (props.element.children.length === 1) {\n    const text = props.element.children[0]\n\n    if (Text.isText(text) && text.text === '') {\n      return (\n        <span style={{ display: 'inline-block', minWidth }} {...props.attributes}>\n          {renderElement(props)}\n        </span>\n      )\n    }\n  }\n\n  return (\n    <span style={{ minWidth }} {...props.attributes}>\n      {renderElement(props)}\n    </span>\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwDM;AAxDN,mBAA+C;AAE/C,uBAAqB;AACrB,oBAAsD;AACtD,qBAA6B;AAC7B,mBAA0B;AAG1B,MAAM,iBAAiB,CAAC,CAAC;AACzB,MAAM,iBAAiB,CAAC,CAAC;AAElB,SAAS,eAAe,QAAwB;AACrD,QAAM,EAAE,cAAc,IAAI;AAC1B,SAAO,gBAAgB,WAAS;AAC9B,UAAM,CAAC,mBAAmB,iBAAiB,IAAI;AAK/C,QAAI,kBAAK,OAAO,gBAAgB,iBAAiB,GAAG;AAClD,8BAAW,WAAW,QAAQ,EAAE,IAAI,eAAe,CAAC;AACpD;AAAA,IACF;AAIA,QACE,kBAAK,WAAW,gBAAgB,iBAAiB,KACjD,4BAAa,QAAQ,iBAAiB,GACtC;AACA,8BAAW,YAAY,QAAQ;AAAA,QAC7B,IAAI;AAAA,MACN,CAAC;AACD;AAAA,IACF;AAIA,QAAI,kBAAK,OAAO,gBAAgB,iBAAiB,GAAG;AAClD,8BAAW,SAAS,QAAQ,EAAE,MAAM,uBAAU,QAAQ,GAAG,EAAE,IAAI,kBAAkB,CAAC;AAClF;AAAA,IACF;AAEA,kBAAc,KAAK;AAAA,EACrB;AAEA,SAAO;AACT;AAEO,SAAS,mBAAmB;AACjC,aAAO,sCAAuB;AAAA,IAC5B,WAAW,CAAC,MAAqB;AAC/B,cAAI,iBAAAA,SAAS,SAAS,CAAC;AAAG,UAAE,eAAe;AAAA,IAC7C;AAAA,IACA,YAAY;AAAA,IACZ,eAAe,mBAAiB,WAC9B,4CAAC,6BAA2B,GAAG,OAAO,eAA8B;AAAA,EACxE,CAAC;AACH;AAEA,MAAM,WAAW,GAAG,qBAAqB,MAAM;AAE/C,SAAS,0BAA0B;AAAA,EACjC;AAAA,EACA,GAAG;AACL,GAA0D;AACxD,MAAI,MAAM,QAAQ,SAAS,WAAW,GAAG;AACvC,UAAM,OAAO,MAAM,QAAQ,SAAS,CAAC;AAErC,QAAI,kBAAK,OAAO,IAAI,KAAK,KAAK,SAAS,IAAI;AACzC,aACE,4CAAC,UAAK,OAAO,EAAE,SAAS,gBAAgB,SAAS,GAAI,GAAG,MAAM,YAC3D,wBAAc,KAAK,GACtB;AAAA,IAEJ;AAAA,EACF;AAEA,SACE,4CAAC,UAAK,OAAO,EAAE,SAAS,GAAI,GAAG,MAAM,YAClC,wBAAc,KAAK,GACtB;AAEJ;","names":["isHotkey"]}

package/dist/cjs/slate/InlinePlugin/getValue.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getValue_exports = {};
+__export(getValue_exports, {
+  getSupportedInlinesAndTextInSelection: () => getSupportedInlinesAndTextInSelection,
+  getValue: () => getValue
+});
+module.exports = __toCommonJS(getValue_exports);
+var import_slate = require("slate");
+var import_element = require("../utils/element");
+var import_selectors = require("../selectors");
+var import_filterForSubtreeRoots = require("../BlockPlugin/utils/filterForSubtreeRoots");
+var import_types = require("./types");
+function getSupportedInlinesAndTextInSelection(editor) {
+  return Array.from(
+    import_slate.Editor.nodes(editor, {
+      at: (0, import_selectors.getSelection)(editor),
+      match: (node) => import_element.ElementUtils.isInline(node) && (0, import_types.isSupportedInlineType)(node.type) || import_slate.Text.isText(node)
+    })
+  );
+}
+const getValue = (editor) => {
+  const roots = (0, import_filterForSubtreeRoots.filterForSubtreeRoots)(getSupportedInlinesAndTextInSelection(editor));
+  const areAllRootsSupportedInlineTypesOrText = roots.every(
+    (entry) => (0, import_types.isSupportedInlineEntry)(entry) || import_slate.Text.isText(entry[0])
+  );
+  if (!areAllRootsSupportedInlineTypesOrText)
+    return void 0;
+  const matchingValues = roots.filter(import_types.isSupportedInlineEntry).map(([node]) => node);
+  const match = matchingValues.reduce(
+    (a, b) => a?.type === b?.type ? b : null,
+    matchingValues.at(0) ?? void 0
+  );
+  return match == null ? match : match.type;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSupportedInlinesAndTextInSelection,
+  getValue
+});
+//# sourceMappingURL=getValue.js.map

package/dist/cjs/slate/InlinePlugin/getValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/slate/InlinePlugin/getValue.ts"],"sourcesContent":["import { Editor, NodeEntry, Text } from 'slate'\nimport { ElementUtils } from '../utils/element'\nimport { getSelection } from '../selectors'\nimport { filterForSubtreeRoots } from '../BlockPlugin/utils/filterForSubtreeRoots'\nimport { SupportedInline, isSupportedInlineType, isSupportedInlineEntry } from './types'\n\nexport function getSupportedInlinesAndTextInSelection(\n  editor: Editor,\n): NodeEntry<SupportedInline | Text>[] {\n  return Array.from(\n    Editor.nodes(editor, {\n      at: getSelection(editor),\n      match: node =>\n        (ElementUtils.isInline(node) && isSupportedInlineType(node.type)) || Text.isText(node),\n    }),\n  ) as NodeEntry<Text | SupportedInline>[]\n}\n\nexport const getValue = (editor: Editor) => {\n  const roots = filterForSubtreeRoots(getSupportedInlinesAndTextInSelection(editor))\n\n  const areAllRootsSupportedInlineTypesOrText = roots.every(\n    entry => isSupportedInlineEntry(entry) || Text.isText(entry[0]),\n  )\n\n  if (!areAllRootsSupportedInlineTypesOrText) return undefined\n\n  const matchingValues = roots.filter(isSupportedInlineEntry).map(([node]) => node) as (\n    | SupportedInline\n    | null\n    | undefined\n  )[]\n\n  const match = matchingValues.reduce(\n    (a, b) => (a?.type === b?.type ? b : null),\n    matchingValues.at(0) ?? undefined,\n  )\n\n  return match == null ? match : match.type\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAwC;AACxC,qBAA6B;AAC7B,uBAA6B;AAC7B,mCAAsC;AACtC,mBAA+E;AAExE,SAAS,sCACd,QACqC;AACrC,SAAO,MAAM;AAAA,IACX,oBAAO,MAAM,QAAQ;AAAA,MACnB,QAAI,+BAAa,MAAM;AAAA,MACvB,OAAO,UACJ,4BAAa,SAAS,IAAI,SAAK,oCAAsB,KAAK,IAAI,KAAM,kBAAK,OAAO,IAAI;AAAA,IACzF,CAAC;AAAA,EACH;AACF;AAEO,MAAM,WAAW,CAAC,WAAmB;AAC1C,QAAM,YAAQ,oDAAsB,sCAAsC,MAAM,CAAC;AAEjF,QAAM,wCAAwC,MAAM;AAAA,IAClD,eAAS,qCAAuB,KAAK,KAAK,kBAAK,OAAO,MAAM,CAAC,CAAC;AAAA,EAChE;AAEA,MAAI,CAAC;AAAuC,WAAO;AAEnD,QAAM,iBAAiB,MAAM,OAAO,mCAAsB,EAAE,IAAI,CAAC,CAAC,IAAI,MAAM,IAAI;AAMhF,QAAM,QAAQ,eAAe;AAAA,IAC3B,CAAC,GAAG,MAAO,GAAG,SAAS,GAAG,OAAO,IAAI;AAAA,IACrC,eAAe,GAAG,CAAC,KAAK;AAAA,EAC1B;AAEA,SAAO,SAAS,OAAO,QAAQ,MAAM;AACvC;","names":[]}