@makeswift/runtime 0.9.12 → 0.10.0

package/dist/react-page.cjs.js

@@ -18,6 +18,18 @@ var __spreadValues = (a, b) => {
   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;
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
@@ -32,11 +44,14 @@ var css = require("@emotion/css");
 var serialize = require("@emotion/serialize");
 var utils = require("@emotion/utils");
 var slate = require("slate");
+var jsxRuntime = require("react/jsx-runtime");
+var isHotkey = require("is-hotkey");
 function _interopDefaultLegacy(e) {
   return e && typeof e === "object" && "default" in e ? e : { "default": e };
 }
 var thunk__default = /* @__PURE__ */ _interopDefaultLegacy(thunk);
 var React__default = /* @__PURE__ */ _interopDefaultLegacy(React);
+var isHotkey__default = /* @__PURE__ */ _interopDefaultLegacy(isHotkey);
 const ComponentIcon = {
   Billing: "billing",
   Bolt: "bolt",
@@ -290,6 +305,12 @@ function reducer$1(state = getInitialState(), action) {
   }
 }
 function parseLocalesInput(input) {
+  if (input.locales == null) {
+    throw new Error(`Locales cannot be null or undefined. Please provide the locales array.`);
+  }
+  if (input.locales.includes(input.defaultLocale) === false) {
+    throw new Error(`Default locale "${input.defaultLocale}" is not included in locales: ${input.locales}. Please add the default locale to the locales array.`);
+  }
   return {
     locales: input.locales.map((locale) => actions.localeStringSchema.parse(locale)),
     defaultLocale: actions.localeStringSchema.parse(input.defaultLocale),
@@ -676,7 +697,7 @@ function Shape$1(options) {
 function introspectShapePropControllerData(descriptor, value, func) {
   if (value == null)
     return [];
-  return Object.entries(descriptor.options.type).flatMap(([key, definition]) => func(definition, value[key]));
+  return Object.entries(descriptor.options.type).flatMap(([key, definition2]) => func(definition2, value[key]));
 }
 function getShapePropControllerElementChildren(descriptor, value) {
   return introspectShapePropControllerData(descriptor, value, getElementChildren);
@@ -1042,32 +1063,32 @@ class ListControl extends PropController {
     this.controls = /* @__PURE__ */ new Map();
   }
 }
-function copyListData(definition, value, context) {
+function copyListData(definition2, value, context) {
   if (value == null)
     return value;
   return value && value.map((item) => __spreadProps(__spreadValues({}, item), {
-    value: copy(definition.config.type, item.value, context)
+    value: copy(definition2.config.type, item.value, context)
   }));
 }
-function introspectListData(definition, value, func) {
+function introspectListData(definition2, value, func) {
   if (value == null)
     return [];
-  return value.flatMap((item) => func(definition.config.type, item.value));
+  return value.flatMap((item) => func(definition2.config.type, item.value));
 }
-function getListElementChildren(definition, value) {
-  return introspectListData(definition, value, getElementChildren);
+function getListElementChildren(definition2, value) {
+  return introspectListData(definition2, value, getElementChildren);
 }
-function getListSwatchIds(definition, value) {
-  return introspectListData(definition, value, getSwatchIds);
+function getListSwatchIds(definition2, value) {
+  return introspectListData(definition2, value, getSwatchIds);
 }
-function getListFileIds(definition, value) {
-  return introspectListData(definition, value, getFileIds);
+function getListFileIds(definition2, value) {
+  return introspectListData(definition2, value, getFileIds);
 }
-function getListTypographyIds(definition, value) {
-  return introspectListData(definition, value, getTypographyIds);
+function getListTypographyIds(definition2, value) {
+  return introspectListData(definition2, value, getTypographyIds);
 }
-function getListPageIds(definition, value) {
-  return introspectListData(definition, value, getPageIds);
+function getListPageIds(definition2, value) {
+  return introspectListData(definition2, value, getPageIds);
 }
 const ShapeControlType = "makeswift::controls::shape";
 function Shape(config) {
@@ -1112,35 +1133,35 @@ class ShapeControl extends PropController {
     this.setControls();
   }
 }
-function copyShapeData(definition, value, context) {
+function copyShapeData(definition2, value, context) {
   if (value == null)
     return value;
   const newValue = {};
-  for (const [key, itemDefinition] of Object.entries(definition.config.type)) {
+  for (const [key, itemDefinition] of Object.entries(definition2.config.type)) {
     const prop = value[key];
     newValue[key] = copy(itemDefinition, prop, context);
   }
   return newValue;
 }
-function introspectShapeData(definition, value, func) {
+function introspectShapeData(definition2, value, func) {
   if (value == null)
     return [];
-  return Object.entries(definition.config.type).flatMap(([key, definition2]) => func(definition2, value[key]));
+  return Object.entries(definition2.config.type).flatMap(([key, definition22]) => func(definition22, value[key]));
 }
-function getShapeElementChildren(definition, data) {
-  return introspectShapeData(definition, data, getElementChildren);
+function getShapeElementChildren(definition2, data) {
+  return introspectShapeData(definition2, data, getElementChildren);
 }
-function getShapeSwatchIds(definition, data) {
-  return introspectShapeData(definition, data, getSwatchIds);
+function getShapeSwatchIds(definition2, data) {
+  return introspectShapeData(definition2, data, getSwatchIds);
 }
-function getShapeTypographyIds(definition, data) {
-  return introspectShapeData(definition, data, getTypographyIds);
+function getShapeTypographyIds(definition2, data) {
+  return introspectShapeData(definition2, data, getTypographyIds);
 }
-function getShapePageIds(definition, data) {
-  return introspectShapeData(definition, data, getPageIds);
+function getShapePageIds(definition2, data) {
+  return introspectShapeData(definition2, data, getPageIds);
 }
-function getShapeFileIds(definition, data) {
-  return introspectShapeData(definition, data, getFileIds);
+function getShapeFileIds(definition2, data) {
+  return introspectShapeData(definition2, data, getFileIds);
 }
 const SlotControlType = "makeswift::controls::slot";
 function Slot() {
@@ -1938,8 +1959,8 @@ function copy$1(descriptor, value, context) {
 function copyElementReference(value, context) {
   return context.replacementContext.globalElementIds.get(value) || value;
 }
-function copy(definition, value, context) {
-  switch (definition.type) {
+function copy(definition2, value, context) {
+  switch (definition2.type) {
     case Types.Backgrounds:
     case Types.Grid:
     case Types.NavigationLinks:
@@ -1953,7 +1974,7 @@ function copy(definition, value, context) {
     case Types.Border:
     case Types.RichText:
     case Types.ElementID:
-      return copy$1(definition, value, context);
+      return copy$1(definition2, value, context);
     case ColorControlType:
       return copyColorData(value, context);
     case ImageControlType:
@@ -1961,9 +1982,9 @@ function copy(definition, value, context) {
     case LinkControlType:
       return copyLinkData(value, context);
     case ShapeControlType:
-      return copyShapeData(definition, value, context);
+      return copyShapeData(definition2, value, context);
     case ListControlType:
-      return copyListData(definition, value, context);
+      return copyListData(definition2, value, context);
     case StyleControlType:
       return copyStyleData(value, context);
     case SlotControlType:
@@ -1972,14 +1993,31 @@ function copy(definition, value, context) {
       return value;
   }
 }
-function merge(definition, a, b = a, context) {
-  switch (definition.type) {
+function merge(definition2, a, b = a, context) {
+  switch (definition2.type) {
     case SlotControlType:
       return mergeSlotData(a, b, context);
     default:
       return b;
   }
 }
+const unstable_IconRadioGroupIcon = {
+  TextAlignCenter: "TextAlignCenter",
+  TextAlignJustify: "TextAlignJustify",
+  TextAlignLeft: "TextAlignLeft",
+  TextAlignRight: "TextAlignRight",
+  Superscript: "Superscript16",
+  Subscript: "Subscript16",
+  Code: "Code16"
+};
+const IconRadioGroupControlType = "makeswift::controls::icon-radio-group";
+function unstable_IconRadioGroup(config) {
+  return { type: IconRadioGroupControlType, config };
+}
+const SelectControlType = "makeswift::controls::select";
+function Select(config) {
+  return { type: SelectControlType, config };
+}
 const isServer = typeof window === "undefined";
 const useInsertionEffectSpecifier = "useInsertionEffect";
 const useInsertionEffect = (_a = React__default["default"][useInsertionEffectSpecifier]) != null ? _a : React__default["default"].useLayoutEffect;
@@ -2045,7 +2083,6 @@ const ObjectType = {
 };
 const RootBlockType = {
   Default: "default",
-  Text: "text-block",
   Paragraph: "paragraph",
   Heading1: "heading-one",
   Heading2: "heading-two",
@@ -2217,7 +2254,6 @@ function toNodeDTO(node) {
     case BlockType.Heading5:
     case BlockType.Heading6:
     case BlockType.Default:
-    case BlockType.Text:
     case BlockType.BlockQuote:
     case BlockType.Paragraph:
     case BlockType.OrderedList:
@@ -2271,9 +2307,6 @@ function richTextDAOToDTO(children, selection) {
   };
 }
 const RichTextControlType = "makeswift::controls::rich-text";
-function RichText() {
-  return { type: RichTextControlType };
-}
 const RichTextControlMessageType = {
   CHANGE_BUILDER_EDIT_MODE: "CHANGE_BUILDER_EDIT_MODE",
   INITIALIZE_EDITOR: "INITIALIZE_EDITOR",
@@ -2351,23 +2384,1354 @@ function richTextV2DescendentsToData(descendants, key) {
     key
   };
 }
-const RichTextV2ControlType = "makeswift::controls::rich-text-v2";
-const RichTextV2Mode = {
-  Inline: "makeswift::controls::rich-text-v2::mode::inline",
-  Block: "makeswift::controls::rich-text-v2::mode::block"
-};
 function createRichTextV2Plugin({
   control,
   withPlugin,
-  onKeyDown,
+  onKeyDown: onKeyDown2,
   renderElement,
   renderLeaf
 }) {
-  return { control, withPlugin, onKeyDown, renderElement, renderLeaf };
+  return { control, withPlugin, onKeyDown: onKeyDown2, renderElement, renderLeaf };
+}
+const ElementUtils = {
+  isRootBlock(node) {
+    return slate.Element.isElement(node) && (slate.Element.isElementType(node, BlockType.Paragraph) || slate.Element.isElementType(node, BlockType.Heading1) || slate.Element.isElementType(node, BlockType.Heading2) || slate.Element.isElementType(node, BlockType.Heading3) || slate.Element.isElementType(node, BlockType.Heading3) || slate.Element.isElementType(node, BlockType.Heading4) || slate.Element.isElementType(node, BlockType.Heading5) || slate.Element.isElementType(node, BlockType.Heading6) || slate.Element.isElementType(node, BlockType.BlockQuote) || slate.Element.isElementType(node, BlockType.UnorderedList) || slate.Element.isElementType(node, BlockType.OrderedList) || slate.Element.isElementType(node, BlockType.Default));
+  },
+  isBlock(node) {
+    return slate.Element.isElement(node) && (this.isRootBlock(node) || slate.Element.isElementType(node, BlockType.ListItem) || slate.Element.isElementType(node, BlockType.ListItemChild));
+  },
+  isInline(node) {
+    return slate.Element.isElementType(node, InlineType.Code) || slate.Element.isElementType(node, InlineType.Link) || slate.Element.isElementType(node, InlineType.SubScript) || slate.Element.isElementType(node, InlineType.SuperScript);
+  },
+  isConvertibleToListTextNode(node) {
+    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
+  },
+  isList(node) {
+    return slate.Element.isElementType(node, BlockType.OrderedList) || slate.Element.isElementType(node, BlockType.UnorderedList);
+  },
+  isListItem(node) {
+    return slate.Element.isElementType(node, BlockType.ListItem);
+  },
+  isListItemChild(node) {
+    return slate.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 isLinkElement(node) {
+  return ElementUtils.isInline(node) && node.type === InlineType.Link;
+}
+function isLinkEntry(inline) {
+  return ElementUtils.isInline(inline[0]) && inline[0].type === InlineType.Link;
+}
+function unhangRange(editor, range) {
+  let [start, end] = slate.Range.edges(range);
+  if (start.offset !== 0 || end.offset !== 0 || slate.Range.isCollapsed(range)) {
+    return range;
+  }
+  const endBlock = slate.Editor.above(editor, {
+    at: end,
+    match: (n) => slate.Element.isElement(n) && slate.Editor.isBlock(editor, n)
+  });
+  const blockPath = endBlock ? endBlock[1] : [];
+  const first = slate.Editor.start(editor, start);
+  const before = { anchor: first, focus: end };
+  let skip = true;
+  for (const [node, path] of slate.Editor.nodes(editor, {
+    at: before,
+    match: slate.Text.isText,
+    reverse: true
+  })) {
+    if (skip) {
+      skip = false;
+      continue;
+    }
+    if (node.text !== "" || slate.Path.isBefore(path, blockPath)) {
+      end = { path, offset: node.text.length };
+      break;
+    }
+  }
+  return { anchor: start, focus: end };
+}
+function is(x, y) {
+  if (x === y)
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  return x !== x && y !== y;
+}
+const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
+const shallowEqual = (a, b) => {
+  if (is(a, b))
+    return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null)
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (let i = 0; i < keysA.length; i += 1) {
+    if (!hasOwnProperty$1.call(b, keysA[i]) || !is(a[keysA[i]], b[keysA[i]]))
+      return false;
+  }
+  return true;
+};
+function isNonNullable(value) {
+  return value != null;
+}
+const { hasOwnProperty } = Object.prototype;
+const deepEqual = (a, b) => {
+  if (shallowEqual(a, b))
+    return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null)
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (let i = 0; i < keysA.length; i += 1) {
+    if (!hasOwnProperty.call(b, keysA[i]) || !deepEqual(a[keysA[i]], b[keysA[i]]))
+      return false;
+  }
+  return true;
+};
+function getSelection(editor) {
+  if (editor.selection)
+    return unhangRange(editor, editor.selection);
+  return {
+    anchor: slate.Editor.start(editor, []),
+    focus: slate.Editor.end(editor, [])
+  };
+}
+function getBlocksInSelection(editor) {
+  return Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: (node) => ElementUtils.isRootBlock(node)
+  })).filter((entry) => ElementUtils.isRootBlock(entry[0]));
+}
+function getActiveBlockType(editor) {
+  var _a2;
+  const rootBlocks = getBlocksInSelection(editor).map(([node]) => node.type);
+  return rootBlocks.reduce((a, b) => a === b ? b : null, (_a2 = rootBlocks.at(0)) != null ? _a2 : null);
+}
+function unwrapInline(editor, type) {
+  slate.Transforms.unwrapNodes(editor, {
+    match: (node) => ElementUtils.isInline(node) && node.type === type,
+    at: getSelection(editor)
+  });
+}
+function wrapInline(editor, inline) {
+  slate.Transforms.wrapNodes(editor, inline, {
+    at: getSelection(editor),
+    split: true
+  });
+}
+function filterForSubtreeRoots(entries) {
+  return entries.filter(([, nodePath]) => !slate.Path.ancestors(nodePath).some((ancestor) => {
+    return entries.some(([, path]) => slate.Path.equals(path, ancestor));
+  }));
+}
+function getLinksAndTextInSelection(editor) {
+  return Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: (node) => ElementUtils.isInline(node) && isLinkElement(node) || slate.Text.isText(node)
+  }));
+}
+const getValue$3 = (editor) => {
+  var _a2;
+  const roots = filterForSubtreeRoots(getLinksAndTextInSelection(editor));
+  const areAllRootsLinks = roots.every(([root]) => isLinkElement(root) || slate.Text.isText(root));
+  if (!areAllRootsLinks)
+    return void 0;
+  const matchingValues = roots.map(([node]) => node).filter(isLinkElement);
+  const match = matchingValues.reduce((a, b) => deepEqual(a == null ? void 0 : a.link, b == null ? void 0 : b.link) ? b : null, (_a2 = matchingValues.at(0)) != null ? _a2 : void 0);
+  return match == null ? match : match.link;
+};
+const onChange$1 = (editor, value) => {
+  if (value == null)
+    return unwrapInline(editor, InlineType.Link);
+  const roots = filterForSubtreeRoots(getLinksAndTextInSelection(editor));
+  const root = roots.at(0);
+  if (roots.length === 1 && root != null && isLinkEntry(root)) {
+    slate.Transforms.setNodes(editor, {
+      link: value
+    }, { at: root[1] });
+  } else {
+    unwrapInline(editor, InlineType.Link);
+    wrapInline(editor, { type: InlineType.Link, link: value, children: [] });
+  }
+};
+function LinkPlugin() {
+  return createRichTextV2Plugin({
+    control: {
+      definition: Link({
+        label: "On Click"
+      }),
+      onChange: onChange$1,
+      getValue: getValue$3,
+      getElementValue: (element) => {
+        return ElementUtils.isInline(element) && isLinkElement(element) ? element.link : void 0;
+      }
+    }
+  });
+}
+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;
+}
+function getSupportedInlinesAndTextInSelection(editor) {
+  return Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: (node) => ElementUtils.isInline(node) && isSupportedInlineType(node.type) || slate.Text.isText(node)
+  }));
+}
+const getValue$2 = (editor) => {
+  var _a2;
+  const roots = filterForSubtreeRoots(getSupportedInlinesAndTextInSelection(editor));
+  const areAllRootsSupportedInlineTypesOrText = roots.every((entry) => isSupportedInlineEntry(entry) || slate.Text.isText(entry[0]));
+  if (!areAllRootsSupportedInlineTypesOrText)
+    return void 0;
+  const matchingValues = roots.filter(isSupportedInlineEntry).map(([node]) => node);
+  const match = matchingValues.reduce((a, b) => (a == null ? void 0 : a.type) === (b == null ? void 0 : b.type) ? b : null, (_a2 = matchingValues.at(0)) != null ? _a2 : void 0);
+  return match == null ? match : match.type;
+};
+const onChange = (editor, value) => {
+  function unwrapAllSupportedTypes() {
+    supportedInlineOptions.forEach(({ value: optionValue }) => unwrapInline(editor, optionValue));
+  }
+  function unwrapAllInlines() {
+    slate.Transforms.unwrapNodes(editor, {
+      match: (node) => ElementUtils.isInline(node),
+      at: getSelection(editor)
+    });
+  }
+  if (value == null)
+    return unwrapAllSupportedTypes();
+  if (!isSupportedInlineType(value))
+    return;
+  const roots = filterForSubtreeRoots(getSupportedInlinesAndTextInSelection(editor));
+  const root = roots.at(0);
+  if (roots.length === 1 && root != null && isSupportedInlineEntry(root) && root[0].type === value) {
+    unwrapInline(editor, value);
+  } else {
+    unwrapAllInlines();
+    wrapInline(editor, { type: value, children: [] });
+  }
+};
+const withInline = (editor) => {
+  const {
+    isInline
+  } = editor;
+  editor.isInline = (entry) => {
+    return ElementUtils.isInline(entry) && isInline(entry);
+  };
+  return editor;
+};
+function InlinePlugin() {
+  return createRichTextV2Plugin({
+    control: {
+      definition: unstable_IconRadioGroup({
+        label: "Inline",
+        options: supportedInlineOptions
+      }),
+      onChange,
+      getValue: getValue$2,
+      getElementValue: (element) => {
+        return ElementUtils.isInline(element) ? element.type : void 0;
+      }
+    },
+    withPlugin: withInline,
+    renderElement: (renderElement) => (props) => {
+      return /* @__PURE__ */ jsxRuntime.jsx(InlinePluginComponent, __spreadProps(__spreadValues({}, props), {
+        renderElement
+      }));
+    }
+  });
+}
+function InlinePluginComponent(_b) {
+  var _c = _b, {
+    renderElement
+  } = _c, props = __objRest(_c, [
+    "renderElement"
+  ]);
+  switch (props.element.type) {
+    case InlineType.Code:
+      return /* @__PURE__ */ jsxRuntime.jsx("code", __spreadProps(__spreadValues({}, props.attributes), {
+        children: renderElement(props)
+      }));
+    case InlineType.SuperScript:
+      return /* @__PURE__ */ jsxRuntime.jsx("sup", __spreadProps(__spreadValues({}, props.attributes), {
+        children: renderElement(props)
+      }));
+    case InlineType.SubScript:
+      return /* @__PURE__ */ jsxRuntime.jsx("sub", __spreadProps(__spreadValues({}, props.attributes), {
+        children: renderElement(props)
+      }));
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, {
+        children: renderElement(props)
+      });
+  }
+}
+function setResponsiveValue(editor, key, value, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    const at = getSelection(editor);
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
+      slate.Transforms.setNodes(editor, {
+        slice: true
+      }, {
+        at: atRef.current,
+        match: options.match,
+        split: options.split
+      });
+    }
+    if (atRef.current) {
+      const nodesToUpdate = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node, path) => options.match(node, path) && node.slice === true
+      }));
+      for (const [, path] of nodesToUpdate) {
+        slate.Transforms.setNodes(editor, {
+          [key]: value
+        }, { at: path });
+      }
+    }
+    atRef.unref();
+  });
+}
+function normalizeResponsiveValue(editor, key, options) {
+  return (entry) => {
+    const [node, path] = entry;
+    if (!options.match(node, path)) {
+      return false;
+    }
+    const responsiveValue = node == null ? void 0 : node[key];
+    if (Array.isArray(responsiveValue) && responsiveValue.length === 0) {
+      slate.Transforms.unsetNodes(editor, key, { at: path });
+      return true;
+    }
+    if ((node == null ? void 0 : node.slice) != null) {
+      slate.Transforms.unsetNodes(editor, "slice", { at: path });
+      return true;
+    }
+    return false;
+  };
+}
+function responsiveShallowEqual(a = [], b = []) {
+  const aObject = a.reduce((acc, curr) => __spreadProps(__spreadValues({}, acc), {
+    [curr.deviceId]: curr.value
+  }), {});
+  const bObject = b.reduce((acc, curr) => __spreadProps(__spreadValues({}, acc), {
+    [curr.deviceId]: curr.value
+  }), {});
+  const definedDevices = /* @__PURE__ */ new Set([...a.map((a2) => a2.deviceId), ...b.map((b2) => b2.deviceId)]);
+  return Array.from(definedDevices).map((deviceId) => {
+    const aVal = aObject[deviceId];
+    const bVal = bObject[deviceId];
+    if (aVal === void 0 && bVal === void 0)
+      return { deviceId, value: void 0 };
+    return shallowEqual(aVal, bVal) ? { deviceId, value: aVal } : { deviceId, value: null };
+  });
+}
+function getValue$1(editor) {
+  const matchingValues = Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: ElementUtils.isRootBlock
+  })).map(([node]) => node["textAlign"]);
+  return matchingValues.length === 0 ? void 0 : matchingValues.reduce((a, b) => {
+    return responsiveShallowEqual(a, b);
+  });
+}
+const TEXT_ALIGN_KEY = "textAlign";
+const withTextAlign = (editor) => {
+  const {
+    normalizeNode
+  } = editor;
+  editor.normalizeNode = (entry) => {
+    if (normalizeResponsiveValue(editor, TEXT_ALIGN_KEY, {
+      match: ElementUtils.isRootBlock
+    })(entry)) {
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+};
+function TextAlignPlugin() {
+  return createRichTextV2Plugin({
+    control: {
+      definition: unstable_StyleV2({
+        type: unstable_IconRadioGroup({
+          label: "Alignment",
+          options: [{
+            icon: unstable_IconRadioGroupIcon.TextAlignLeft,
+            label: "Left Align",
+            value: "left"
+          }, {
+            icon: unstable_IconRadioGroupIcon.TextAlignCenter,
+            label: "Center Align",
+            value: "center"
+          }, {
+            icon: unstable_IconRadioGroupIcon.TextAlignRight,
+            label: "Right Align",
+            value: "right"
+          }, {
+            icon: unstable_IconRadioGroupIcon.TextAlignJustify,
+            label: "Justify",
+            value: "justify"
+          }],
+          defaultValue: "left"
+        }),
+        getStyle(textAlign) {
+          return {
+            textAlign
+          };
+        }
+      }),
+      onChange: (editor, value) => setResponsiveValue(editor, TEXT_ALIGN_KEY, value, {
+        match: ElementUtils.isRootBlock,
+        split: false
+      }),
+      getValue: (editor) => getValue$1(editor),
+      getElementValue: (element) => {
+        return ElementUtils.isRootBlock(element) ? element.textAlign : void 0;
+      }
+    },
+    withPlugin: withTextAlign,
+    renderElement: (renderElement, className) => (props) => {
+      return renderElement(__spreadProps(__spreadValues({}, props), {
+        element: __spreadProps(__spreadValues({}, props.element), {
+          className
+        })
+      }));
+    }
+  });
+}
+function setBlockKeyForDevice(editor, breakpoints, deviceId, key, value, options) {
+  var _a2, _b;
+  const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : 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 = state_breakpoints.findBreakpointOverride(breakpoints, deviceValues, deviceId, (v) => v);
+      const nextDeviceValue = __spreadProps(__spreadValues({}, currentDeviceValue), {
+        deviceId,
+        value
+      });
+      slate.Transforms.setNodes(editor, {
+        [key]: [...deviceValues.filter((v) => v.deviceId !== deviceId), nextDeviceValue]
+      }, { at: path });
+    }
+  }
+}
+function clearBlockKeyForDevice(editor, deviceId, key) {
+  var _a2;
+  const rootElements = getBlocksInSelection(editor);
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceOverrides = (_a2 = node[key]) != null ? _a2 : [];
+      slate.Transforms.setNodes(editor, {
+        [key]: deviceOverrides.filter((v) => v.deviceId !== deviceId)
+      }, { at: path });
+    }
+  }
+}
+const EditorUtils = {
+  getFirstAncestorList(editor, path) {
+    try {
+      const parentList = slate.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 = slate.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 unwrapPath(editor, listItemPath) {
+  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
+  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
+  if (!parentList || listItemContainingParentList)
+    return;
+  slate.Editor.withoutNormalizing(editor, () => {
+    const listItemTextPath = [...listItemPath, LIST_ITEM_CHILD_POSITION];
+    const listItemNestedListPath = [...listItemPath, LIST_ITEM_LIST_POSITION];
+    if (slate.Node.has(editor, listItemNestedListPath)) {
+      slate.Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath });
+      slate.Transforms.liftNodes(editor, { at: listItemNestedListPath });
+      slate.Transforms.liftNodes(editor, { at: slate.Path.next(listItemPath) });
+    }
+    if (slate.Node.has(editor, listItemTextPath)) {
+      slate.Transforms.setNodes(editor, { type: BlockType.Paragraph }, {
+        at: listItemTextPath
+      });
+      slate.Transforms.liftNodes(editor, { at: listItemTextPath });
+      slate.Transforms.liftNodes(editor, { at: listItemPath });
+    }
+  });
+}
+function unwrapList(editor, options) {
+  var _a2;
+  const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+  if (!at)
+    return;
+  const listItems = Array.from(slate.Editor.nodes(editor, {
+    at,
+    match: (node) => {
+      return slate.Element.isElement(node) && ElementUtils.isListItem(node);
+    }
+  }));
+  const subRoots = filterForSubtreeRoots(listItems);
+  const refs = subRoots.map(([_, path]) => slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      unwrapPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function wrapList(editor, options = { type: BlockType.UnorderedList }) {
+  var _a2;
+  const at = (_a2 = options.at) != null ? _a2 : editor.selection;
+  if (!at)
+    return;
+  const nonListEntries = Array.from(slate.Editor.nodes(editor, {
+    at,
+    match: (node) => {
+      return slate.Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node);
+    }
+  }));
+  const refs = nonListEntries.map(([_, path]) => slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    const path = ref.current;
+    if (path) {
+      slate.Editor.withoutNormalizing(editor, () => {
+        slate.Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
+          at: path
+        });
+        slate.Transforms.wrapNodes(editor, ElementUtils.createListItem(), {
+          match: (node) => ElementUtils.isListItemChild(node),
+          at: path
+        });
+        slate.Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {
+          at: path
+        });
+      });
+    }
+    ref.unref();
+  });
+}
+const LocationUtils = {
+  getStartPath(location) {
+    if (slate.Range.isRange(location))
+      return slate.Range.start(location).path;
+    if (slate.Point.isPoint(location))
+      return location.path;
+    return location;
+  }
+};
+function getSelectedListItems(editor) {
+  var _a2, _b;
+  if (!editor.selection)
+    return [];
+  const start = LocationUtils.getStartPath(editor.selection);
+  const listItems = slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => ElementUtils.isListItem(node)
+  });
+  const firstAncestorPath = (_b = (_a2 = EditorUtils.getFirstAncestorListItem(editor, start)) == null ? void 0 : _a2[1]) != null ? _b : [];
+  return Array.from(listItems).filter((node) => slate.Path.isDescendant(start, node[1]) ? slate.Path.equals(node[1], firstAncestorPath) : !slate.Path.isAfter(start, node[1]));
+}
+function indentPath(editor, path) {
+  const parent = slate.Node.parent(editor, path);
+  if (!path || !slate.Path.hasPrevious(path) || !ElementUtils.isList(parent))
+    return;
+  const previosPath = slate.Path.previous(path);
+  const previousChildListPath = [...previosPath, LIST_ITEM_LIST_POSITION];
+  const previousHasChildList = slate.Node.has(editor, previousChildListPath);
+  slate.Editor.withoutNormalizing(editor, () => {
+    if (!previousHasChildList) {
+      slate.Transforms.insertNodes(editor, ElementUtils.createList(parent.type), {
+        at: previousChildListPath
+      });
+    }
+    const previousChildList = slate.Node.get(editor, previousChildListPath);
+    if (ElementUtils.isList(previousChildList)) {
+      const index = previousHasChildList ? previousChildList.children.length : 0;
+      slate.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]) => slate.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);
+  slate.Editor.withoutNormalizing(editor, () => {
+    nextSiblings.forEach(() => {
+      const nextSiblingPath = [...parentListPath, listItemPosition + 1];
+      indentPath(editor, nextSiblingPath);
+    });
+    slate.Transforms.moveNodes(editor, {
+      at: listItemPath,
+      to: slate.Path.next(listItemContainingParentListPath)
+    });
+    if (previousSiblings.length === 0) {
+      slate.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]) => slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      dedentPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function toggleList(editor, options = { type: BlockType.UnorderedList }) {
+  var _a2;
+  const at = (_a2 = options.at) != null ? _a2 : editor.selection;
+  if (at == null)
+    return;
+  const start = LocationUtils.getStartPath(at);
+  const ancestorPath = slate.Path.ancestors(start).at(1);
+  if (!ancestorPath || !slate.Node.has(editor, ancestorPath))
+    return;
+  const ancestor = slate.Node.get(editor, ancestorPath);
+  if (!ElementUtils.isList(ancestor)) {
+    return wrapList(editor, { type: options.type, at });
+  }
+  if (ancestor.type === options.type) {
+    unwrapList(editor, { at });
+  } else {
+    slate.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(slate.Editor.nodes(editor, {
+    match: (node) => ElementUtils.isListItem(node)
+  })).length === 0)
+    return;
+  if (isHotkey__default["default"]("shift+tab", e)) {
+    e.preventDefault();
+    ListActions.dedent(editor);
+  }
+  if (isHotkey__default["default"]("tab", e)) {
+    e.preventDefault();
+    ListActions.indent(editor);
+  }
+  if (isHotkey__default["default"]("backspace", e)) {
+    if (!editor.selection)
+      return;
+    if (slate.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__default["default"]("enter", e)) {
+    e.preventDefault();
+    if (!editor.selection)
+      return;
+    if (slate.Range.isExpanded(editor.selection)) {
+      slate.Transforms.delete(editor);
+      return;
+    }
+    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
+    if (editor.selection.anchor.offset === 0 && listItem && slate.Editor.string(editor, listItem[1]) === "") {
+      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
+      if (parentListItem) {
+        ListActions.dedent(editor);
+      } else {
+        ListActions.unwrapList(editor);
+      }
+      return;
+    }
+    slate.Transforms.splitNodes(editor, {
+      at: editor.selection,
+      always: true,
+      match: (node) => ElementUtils.isListItem(node)
+    });
+  }
+  if (isHotkey__default["default"]("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 _a2;
+    const [normalizationNode, normalizationPath] = entry;
+    if (ElementUtils.isBlock(normalizationNode) && ((_a2 = normalizationNode == null ? void 0 : normalizationNode.textAlign) == null ? void 0 : _a2.length) == 0) {
+      slate.Transforms.unsetNodes(editor, "textAlign", {
+        at: normalizationPath
+      });
+      return;
+    }
+    if (ElementUtils.isListItem(normalizationNode)) {
+      const pathToListItemText = [...normalizationPath, LIST_ITEM_CHILD_POSITION];
+      if (slate.Node.has(editor, pathToListItemText)) {
+        const nodeInListItemTextPosition = slate.Node.get(editor, pathToListItemText);
+        if (ElementUtils.isRootBlock(nodeInListItemTextPosition)) {
+          slate.Transforms.setNodes(editor, {
+            type: BlockType.ListItemChild
+          }, {
+            at: pathToListItemText
+          });
+          return;
+        }
+      } else {
+        slate.Transforms.insertNodes(editor, ElementUtils.createListItem(), {
+          at: pathToListItemText
+        });
+        return;
+      }
+    }
+    if (!slate.Text.isText(normalizationNode)) {
+      const mergeableChildren = Array.from(slate.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 [slate.Editor.pathRef(editor, child[1]), slate.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(slate.Node.children(editor, nodePath));
+          const childrenToBeMerged = Array.from(slate.Node.children(editor, nodeToBeMergedPath));
+          slate.Editor.withoutNormalizing(editor, () => {
+            childrenToBeMerged.reverse().forEach(([_, childPath]) => {
+              slate.Transforms.moveNodes(editor, {
+                at: childPath,
+                to: [...nodePath, nodeChildren.length]
+              });
+            });
+            slate.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) {
+          slate.Transforms.setNodes(editor, {
+            type: BlockType.Default
+          }, {
+            at: getSelection(editor)
+          });
+        } else {
+          ListActions.unwrapList(editor, {
+            at: getSelection(editor)
+          });
+          slate.Transforms.setNodes(editor, {
+            type: value != null ? value : BlockType.Default
+          }, {
+            at: getSelection(editor)
+          });
+        }
+      },
+      getValue: (editor) => {
+        const activeBlock = getActiveBlockType(editor);
+        if (activeBlock === RootBlockType.Default)
+          return void 0;
+        return activeBlock;
+      }
+    },
+    renderElement: (renderElement) => (props) => /* @__PURE__ */ jsxRuntime.jsx(BlockPluginComponent, __spreadProps(__spreadValues({}, props), {
+      renderElement
+    }))
+  });
+}
+function BlockPluginComponent(_d) {
+  var _e = _d, {
+    renderElement
+  } = _e, props = __objRest(_e, [
+    "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.Default:
+    case BlockType.Paragraph:
+      return /* @__PURE__ */ jsxRuntime.jsx("p", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading1:
+      return /* @__PURE__ */ jsxRuntime.jsx("h1", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading2:
+      return /* @__PURE__ */ jsxRuntime.jsx("h2", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading3:
+      return /* @__PURE__ */ jsxRuntime.jsx("h3", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading4:
+      return /* @__PURE__ */ jsxRuntime.jsx("h4", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading5:
+      return /* @__PURE__ */ jsxRuntime.jsx("h5", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.Heading6:
+      return /* @__PURE__ */ jsxRuntime.jsx("h6", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.BlockQuote:
+      return /* @__PURE__ */ jsxRuntime.jsx("blockquote", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles, quoteStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.OrderedList:
+      return /* @__PURE__ */ jsxRuntime.jsx("ol", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles, orderedListStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.UnorderedList:
+      return /* @__PURE__ */ jsxRuntime.jsx("ul", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles, unorderedListStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.ListItem:
+      return /* @__PURE__ */ jsxRuntime.jsx("li", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    case BlockType.ListItemChild:
+      return /* @__PURE__ */ jsxRuntime.jsx("span", __spreadProps(__spreadValues({}, props.attributes), {
+        className: css.cx(...blockStyles),
+        children: renderElement(props)
+      }));
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, {
+        children: renderElement(props)
+      });
+  }
+}
+function clearActiveTypographyStyle(editor, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a2;
+    const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
+      slate.Transforms.setNodes(editor, {
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
+    }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const typography = __spreadProps(__spreadValues({}, node.typography), {
+            style: []
+          });
+          slate.Transforms.setNodes(editor, {
+            typography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
+}
+function clearDeviceActiveTypography(editor, currentDeviceId, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a2, _b, _c;
+    const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
+      slate.Transforms.setNodes(editor, {
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
+    }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const typography = __spreadProps(__spreadValues({}, node.typography), {
+            style: (_c = (_b = node == null ? void 0 : node.typography) == null ? void 0 : _b.style.filter(({ deviceId }) => deviceId !== currentDeviceId)) != null ? _c : []
+          });
+          slate.Transforms.setNodes(editor, {
+            typography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
+}
+function detachActiveTypography(editor, value, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a2;
+    const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
+      slate.Transforms.setNodes(editor, {
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
+    }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          slate.Transforms.setNodes(editor, {
+            typography: {
+              style: value
+            }
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
 }
-function unstable_RichTextV2(config = {}) {
-  return { type: RichTextV2ControlType, config };
+function setActiveTypographyId(editor, id, options) {
+  var _a2;
+  const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+  if (!at)
+    return;
+  slate.Transforms.setNodes(editor, {
+    typography: {
+      id,
+      style: []
+    }
+  }, {
+    at,
+    match: (node) => slate.Text.isText(node),
+    split: slate.Range.isExpanded(at)
+  });
+}
+function setActiveTypographyStyle(editor, breakpoints, deviceId, prop, value, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a2, _b, _c;
+    const at = (_a2 = options == null ? void 0 : options.at) != null ? _a2 : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
+      slate.Transforms.setNodes(editor, {
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
+    }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const deviceOverrides = (_c = (_b = node == null ? void 0 : node.typography) == null ? void 0 : _b.style) != null ? _c : [];
+          const deviceStyle = state_breakpoints.findBreakpointOverride(breakpoints, deviceOverrides, deviceId, (v) => v) || {
+            value: {}
+          };
+          const nextDeviceStyle = {
+            deviceId,
+            value: __spreadProps(__spreadValues({}, deviceStyle.value), { [prop]: value })
+          };
+          const nextTypography = __spreadProps(__spreadValues({}, node.typography), {
+            style: [...deviceOverrides.filter((v) => v.deviceId !== deviceId), nextDeviceStyle]
+          });
+          slate.Transforms.setNodes(editor, {
+            typography: nextTypography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
 }
+function getValue(editor) {
+  const matchingValues = Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: slate.Text.isText
+  })).map(([node]) => node["typography"]);
+  return matchingValues;
+}
+const TypographyActions = {
+  setActiveTypographyId,
+  setActiveTypographyStyle,
+  clearActiveTypographyStyle,
+  clearDeviceActiveTypography,
+  detachActiveTypography
+};
+const TYPOGRAPHY_KEY = "typography";
+function withTypography(editor) {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    var _a2, _b;
+    const [normalizationNode, normalizationPath] = entry;
+    if (slate.Text.isText(normalizationNode) && ((_a2 = normalizationNode == null ? void 0 : normalizationNode.typography) == null ? void 0 : _a2.id) == null && ((_b = normalizationNode == null ? void 0 : normalizationNode.typography) == null ? void 0 : _b.style.length) === 0) {
+      slate.Transforms.unsetNodes(editor, TYPOGRAPHY_KEY, { at: normalizationPath });
+      return;
+    }
+    if (slate.Text.isText(normalizationNode) && (normalizationNode == null ? void 0 : normalizationNode.slice) != null) {
+      slate.Transforms.unsetNodes(editor, "slice", { at: normalizationPath });
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+function TypographyPlugin() {
+  return createRichTextV2Plugin({
+    withPlugin: withTypography,
+    control: {
+      definition: unstable_Typography(),
+      onChange: (editor, value) => {
+        slate.Editor.withoutNormalizing(editor, () => {
+          const at = getSelection(editor);
+          if (!at)
+            return;
+          const atRef = slate.Editor.rangeRef(editor, at);
+          if (atRef.current) {
+            slate.Transforms.setNodes(editor, {
+              slice: true
+            }, {
+              at: atRef.current,
+              match: slate.Text.isText,
+              split: true
+            });
+          }
+          if (atRef.current) {
+            const nodesToUpdate = Array.from(slate.Editor.nodes(editor, {
+              at: atRef.current,
+              match: (node) => slate.Text.isText(node) && node.slice === true
+            }));
+            if (nodesToUpdate.length !== (value == null ? void 0 : value.length))
+              return console.error(`TypographyControl.onChange received the wrong number of arguments.
+Called with ${value == null ? void 0 : value.length} values mapping to ${nodesToUpdate.length} nodes.`);
+            for (const [index, [, path]] of nodesToUpdate.entries()) {
+              slate.Transforms.setNodes(editor, {
+                typography: value == null ? void 0 : value.at(index)
+              }, { at: path, match: slate.Text.isText });
+            }
+          }
+          atRef.unref();
+        });
+      },
+      getValue: (editor) => getValue(editor),
+      getLeafValue: (text) => {
+        return slate.Text.isText(text) ? text.typography : void 0;
+      }
+    },
+    renderLeaf: (renderLeaf, className) => (props) => {
+      return renderLeaf(__spreadProps(__spreadValues({}, props), {
+        leaf: __spreadProps(__spreadValues({}, props.leaf), {
+          className: `${props.leaf.className} ${className}`
+        })
+      }));
+    }
+  });
+}
+const BLOCK_ONE_PATH = [0];
+const BLOCK_TWO_PATH = [1];
+function withInlineMode(editor) {
+  const {
+    normalizeNode
+  } = editor;
+  editor.normalizeNode = (entry) => {
+    const [normalizationNode, normalizationPath] = entry;
+    if (slate.Path.equals(BLOCK_TWO_PATH, normalizationPath)) {
+      slate.Transforms.mergeNodes(editor, {
+        at: BLOCK_TWO_PATH
+      });
+      return;
+    }
+    if (slate.Path.isAncestor(BLOCK_ONE_PATH, normalizationPath) && ElementUtils.isBlock(normalizationNode)) {
+      slate.Transforms.unwrapNodes(editor, {
+        at: normalizationPath
+      });
+      return;
+    }
+    if (slate.Path.equals(BLOCK_ONE_PATH, normalizationPath)) {
+      slate.Transforms.setNodes(editor, {
+        type: BlockType.Default
+      }, {
+        at: normalizationPath
+      });
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+function InlineModePlugin() {
+  return createRichTextV2Plugin({
+    onKeyDown: (e) => {
+      if (isHotkey__default["default"]("enter", e))
+        e.preventDefault();
+    },
+    withPlugin: withInlineMode,
+    renderElement: (renderElement) => (props) => /* @__PURE__ */ jsxRuntime.jsx(InlineModePluginComponent, __spreadProps(__spreadValues({}, props), {
+      renderElement
+    }))
+  });
+}
+function InlineModePluginComponent(_f) {
+  var _g = _f, {
+    renderElement
+  } = _g, props = __objRest(_g, [
+    "renderElement"
+  ]);
+  return /* @__PURE__ */ jsxRuntime.jsx("span", __spreadProps(__spreadValues({}, props.attributes), {
+    children: renderElement(props)
+  }));
+}
+const RichTextV2ControlType = "makeswift::controls::rich-text-v2";
+const RichTextV2Mode = {
+  Inline: "makeswift::controls::rich-text-v2::mode::inline",
+  Block: "makeswift::controls::rich-text-v2::mode::block"
+};
+function RichText(config = {}) {
+  return {
+    type: RichTextV2ControlType,
+    config: {
+      mode: config.mode,
+      defaultValue: config == null ? void 0 : config.unstable_defaultValue,
+      plugins: (config == null ? void 0 : config.mode) === RichTextV2Mode.Inline ? [InlineModePlugin()] : [BlockPlugin(), TypographyPlugin(), TextAlignPlugin(), InlinePlugin(), LinkPlugin()]
+    }
+  };
+}
+RichText.Mode = RichTextV2Mode;
 const RichTextV2ControlMessageType = {
   RESET_VALUE: "makeswift::controls::rich-text-v2::control-message::reset-value",
   FOCUS: "makeswift::controls::rich-text-v2::control-message::focus",
@@ -2401,6 +3765,7 @@ class RichTextV2Control extends PropController {
             this.editor.selection = null;
             this.editor.children = this.defaultValue;
             this.editor.onChange();
+            this.onLocalUserChange();
           }
           break;
         }
@@ -2477,10 +3842,7 @@ class RichTextV2Control extends PropController {
   }
 }
 function isRichTextV1Data(value) {
-  return value !== void 0 && typeof value === "object" && !Array.isArray(value) && "object" in value;
-}
-function isNonNullable(value) {
-  return value != null;
+  return value !== void 0 && typeof value === "object" && !Array.isArray(value) && "document" in value;
 }
 const TypographyControlType = "makeswift::controls::typography";
 function unstable_Typography() {
@@ -2586,8 +3948,8 @@ function getRichTextPageIds(value) {
     }
   }
 }
-function introspectRichTextV2Data(definition, data, func) {
-  const plugins = definition.config.plugins;
+function introspectRichTextV2Data(definition2, data, func) {
+  const plugins = definition2.config.plugins;
   return data.descendants.flatMap((d) => getDescendantTypographyIds(d));
   function getDescendantTypographyIds(descendant) {
     if (slate.Element.isElement(descendant)) {
@@ -2616,14 +3978,14 @@ function introspectRichTextV2Data(definition, data, func) {
     })) != null ? _a2 : [];
   }
 }
-function getRichTextV2SwatchIds(definition, data) {
-  return introspectRichTextV2Data(definition, data, getSwatchIds);
+function getRichTextV2SwatchIds(definition2, data) {
+  return introspectRichTextV2Data(definition2, data, getSwatchIds);
 }
-function getRichTextV2TypographyIds(definition, data) {
-  return introspectRichTextV2Data(definition, data, getTypographyIds);
+function getRichTextV2TypographyIds(definition2, data) {
+  return introspectRichTextV2Data(definition2, data, getTypographyIds);
 }
-function getRichTextV2PageIds(definition, data) {
-  return introspectRichTextV2Data(definition, data, getPageIds);
+function getRichTextV2PageIds(definition2, data) {
+  return introspectRichTextV2Data(definition2, data, getPageIds);
 }
 function getElementChildren(descriptor, prop) {
   if (prop == null)
@@ -3125,6 +4487,8 @@ function configureStore({
   }), redux.applyMiddleware(thunk__default["default"]));
 }
 exports.Backgrounds = Backgrounds;
+exports.BlockActions = BlockActions;
+exports.BlockPlugin = BlockPlugin;
 exports.BlockTextAlignment = BlockTextAlignment;
 exports.BlockType = BlockType;
 exports.Border = Border;
@@ -3138,20 +4502,25 @@ exports.ColorControlType = ColorControlType;
 exports.ComponentIcon = ComponentIcon;
 exports.Date = Date;
 exports.ElementID = ElementID;
+exports.ElementUtils = ElementUtils;
 exports.Font = Font;
 exports.GapX = GapX;
 exports.GapY = GapY;
 exports.Grid = Grid;
+exports.IconRadioGroupControlType = IconRadioGroupControlType;
 exports.Image = Image$1;
 exports.Image$1 = Image;
 exports.ImageControlType = ImageControlType;
 exports.ImageControlValueFormat = ImageControlValueFormat;
 exports.Images = Images;
+exports.InlineModePlugin = InlineModePlugin;
+exports.InlinePlugin = InlinePlugin;
 exports.InlineType = InlineType;
 exports.Link = Link$1;
 exports.Link$1 = Link;
 exports.LinkControlType = LinkControlType;
 exports.List = List;
+exports.ListActions = ListActions;
 exports.ListControl = ListControl;
 exports.ListControlMessageType = ListControlMessageType;
 exports.ListControlType = ListControlType;
@@ -3168,8 +4537,7 @@ exports.ResponsiveLength = ResponsiveLength;
 exports.ResponsiveNumber = ResponsiveNumber;
 exports.ResponsiveOpacity = ResponsiveOpacity;
 exports.ResponsiveSelect = ResponsiveSelect;
-exports.RichText = RichText$1;
-exports.RichText$1 = RichText;
+exports.RichText = RichText;
 exports.RichTextControl = RichTextControl;
 exports.RichTextControlMessageType = RichTextControlMessageType;
 exports.RichTextControlType = RichTextControlType;
@@ -3179,6 +4547,8 @@ exports.RichTextV2ControlMessageType = RichTextV2ControlMessageType;
 exports.RichTextV2ControlType = RichTextV2ControlType;
 exports.RichTextV2Mode = RichTextV2Mode;
 exports.RootBlockType = RootBlockType;
+exports.Select = Select;
+exports.SelectControlType = SelectControlType;
 exports.Shadows = Shadows;
 exports.ShadowsPropControllerFormat = ShadowsPropControllerFormat;
 exports.Shape = Shape;
@@ -3198,14 +4568,18 @@ exports.StyleControlType = StyleControlType;
 exports.StyleV2Control = StyleV2Control;
 exports.StyleV2ControlMessageType = StyleV2ControlMessageType;
 exports.StyleV2ControlType = StyleV2ControlType;
+exports.TYPOGRAPHY_KEY = TYPOGRAPHY_KEY;
 exports.Table = Table;
 exports.TableFormFields = TableFormFields;
 exports.TableFormFieldsMessageType = TableFormFieldsMessageType;
+exports.TextAlignPlugin = TextAlignPlugin;
 exports.TextArea = TextArea;
 exports.TextInput = TextInput;
 exports.TextStyle = TextStyle;
 exports.Types = Types;
+exports.TypographyActions = TypographyActions;
 exports.TypographyControlType = TypographyControlType;
+exports.TypographyPlugin = TypographyPlugin;
 exports.Video = Video;
 exports.Width = Width;
 exports.WidthPropControllerFormat = WidthPropControllerFormat;
@@ -3223,6 +4597,7 @@ exports.createDocument = createDocument;
 exports.createDocumentReference = createDocumentReference;
 exports.createPropController = createPropController;
 exports.createRichTextV2Plugin = createRichTextV2Plugin;
+exports.deepEqual = deepEqual;
 exports.descriptors = descriptors;
 exports.getBackgroundsFileIds = getBackgroundsFileIds;
 exports.getBackgroundsSwatchIds = getBackgroundsSwatchIds;
@@ -3269,13 +4644,17 @@ exports.getTableIds = getTableIds;
 exports.getTypographyIds = getTypographyIds;
 exports.getTypographySwatchIds = getTypographySwatchIds;
 exports.getTypographyTypographyIds = getTypographyTypographyIds;
+exports.getValue = getValue$3;
 exports.introspection = introspection;
 exports.isElementReference = isElementReference;
+exports.isLinkElement = isLinkElement;
 exports.isNonNullable = isNonNullable;
 exports.isPropControllersHandle = isPropControllersHandle;
 exports.isRichTextV1Data = isRichTextV1Data;
 exports.merge = merge;
 exports.mergeSlotData = mergeSlotData;
+exports.onChange = onChange$1;
+exports.onKeyDown = onKeyDown;
 exports.parseLocalesInput = parseLocalesInput;
 exports.reducer = reducer$8;
 exports.reducer$1 = reducer$7;
@@ -3292,9 +4671,15 @@ exports.richTextDTOtoSelection = richTextDTOtoSelection;
 exports.richTextV2DataToDescendents = richTextV2DataToDescendents;
 exports.richTextV2DescendentsToData = richTextV2DescendentsToData;
 exports.toSelectionDTO = toSelectionDTO;
-exports.unstable_RichTextV2 = unstable_RichTextV2;
+exports.unstable_IconRadioGroup = unstable_IconRadioGroup;
+exports.unstable_IconRadioGroupIcon = unstable_IconRadioGroupIcon;
 exports.unstable_StyleV2 = unstable_StyleV2;
 exports.unstable_Typography = unstable_Typography;
 exports.unstable_useStyleV2ClassName = unstable_useStyleV2ClassName;
 exports.useStyle = useStyle;
+exports.withBlock = withBlock;
+exports.withInline = withInline;
+exports.withInlineMode = withInlineMode;
+exports.withTextAlign = withTextAlign;
+exports.withTypography = withTypography;
 //# sourceMappingURL=react-page.cjs.js.map