@makeswift/runtime 0.8.10 → 0.9.0

package/dist/{descriptors.cjs.js → react-page.cjs.js}

@@ -22,17 +22,235 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var redux = require("redux");
+var thunk = require("redux-thunk");
 var actions = require("./actions.cjs.js");
-var slate = require("./slate.cjs2.js");
+var state_breakpoints = require("./state/breakpoints.cjs.js");
+var slate = require("slate");
+var isHotkey = require("is-hotkey");
+require("slate-react");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var thunk__default = /* @__PURE__ */ _interopDefaultLegacy(thunk);
+var isHotkey__default = /* @__PURE__ */ _interopDefaultLegacy(isHotkey);
+const ComponentIcon = {
+  Billing: "billing",
+  Bolt: "bolt",
+  Button: "button",
+  Carousel: "carousel",
+  Chats: "chats",
+  Code: "code",
+  Countdown: "countdown",
+  Cube: "cube",
+  Database: "database",
+  Divider: "divider",
+  Form: "form",
+  Gallery: "gallery",
+  Help: "help",
+  Image: "image",
+  Layout: "layout",
+  Lock: "lock",
+  Navigation: "navigation",
+  SocialLinks: "social-links",
+  Star: "star",
+  Text: "text",
+  Users: "users",
+  Video: "video"
+};
+function getInitialState$8({
+  componentsMeta = /* @__PURE__ */ new Map()
+} = {}) {
+  return componentsMeta;
+}
+function getComponentsMeta(state) {
+  return state;
+}
+function reducer$9(state = getInitialState$8(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.meta);
+    case actions.ActionTypes.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function isElementReference(element) {
+  return !("props" in element);
+}
+function createDocumentReference(key) {
+  return { key };
+}
+function createDocument(key, rootElement) {
+  return { key, rootElement };
+}
+function getInitialState$7({
+  rootElements = /* @__PURE__ */ new Map()
+} = {}) {
+  const initialState = /* @__PURE__ */ new Map();
+  rootElements.forEach((rootElement, documentKey) => {
+    initialState.set(documentKey, createDocument(documentKey, rootElement));
+  });
+  return initialState;
+}
+function getDocuments(state) {
+  return state;
+}
+function getDocument$1(state, documentKey) {
+  var _a;
+  return (_a = getDocuments(state).get(documentKey)) != null ? _a : null;
+}
+function reducer$8(state = getInitialState$7(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_DOCUMENT:
+      return new Map(state).set(action.payload.documentKey, action.payload.document);
+    case actions.ActionTypes.UNREGISTER_DOCUMENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.documentKey);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState$6({
+  reactComponents = /* @__PURE__ */ new Map()
+} = {}) {
+  return reactComponents;
+}
+function getReactComponents(state) {
+  return state;
+}
+function getReactComponent$1(state, type) {
+  var _a;
+  return (_a = getReactComponents(state).get(type)) != null ? _a : null;
+}
+function reducer$7(state = getInitialState$6(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_REACT_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.component);
+    case actions.ActionTypes.UNREGISTER_REACT_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState$5({
+  propControllerDescriptors = /* @__PURE__ */ new Map()
+} = {}) {
+  return propControllerDescriptors;
+}
+function getPropControllerDescriptors$1(state) {
+  return state;
+}
+function getComponentPropControllerDescriptors$1(state, componentType) {
+  var _a;
+  return (_a = getPropControllerDescriptors$1(state).get(componentType)) != null ? _a : null;
+}
+function reducer$6(state = getInitialState$5(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.propControllerDescriptors);
+    case actions.ActionTypes.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
+function isPropControllersHandle(value) {
+  if (typeof value === "object" && value !== null && "setPropControllers" in value && typeof value.setPropControllers === "function") {
+    return true;
+  }
+  return false;
+}
+function getInitialState$4() {
+  return { handles: /* @__PURE__ */ new Map(), instances: /* @__PURE__ */ new Map() };
+}
+function getPropControllersHandle(state, documentKey, elementKey) {
+  var _a, _b;
+  return (_b = (_a = state.handles.get(documentKey)) == null ? void 0 : _a.get(elementKey)) != null ? _b : null;
+}
+function getPropControllers$1(state, documentKey, elementKey) {
+  var _a, _b;
+  return (_b = (_a = state.instances.get(documentKey)) == null ? void 0 : _a.get(elementKey)) != null ? _b : null;
+}
+function getPropController(state, documentKey, elementKey, propName) {
+  var _a, _b;
+  return (_b = (_a = getPropControllers$1(state, documentKey, elementKey)) == null ? void 0 : _a[propName]) != null ? _b : null;
+}
+function reducer$5(state = getInitialState$4(), action) {
+  var _a, _b, _c, _d;
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_PROP_CONTROLLERS_HANDLE: {
+      const { documentKey, elementKey, handle } = action.payload;
+      return __spreadProps(__spreadValues({}, state), {
+        handles: new Map(state.handles).set(documentKey, new Map((_a = state.handles.get(documentKey)) != null ? _a : []).set(elementKey, handle))
+      });
+    }
+    case actions.ActionTypes.UNREGISTER_PROP_CONTROLLERS_HANDLE: {
+      const { documentKey, elementKey } = action.payload;
+      const nextHandles = new Map((_b = state.handles.get(documentKey)) != null ? _b : []);
+      const deleted = nextHandles.delete(elementKey);
+      return deleted ? __spreadProps(__spreadValues({}, state), { handles: new Map(state.handles).set(documentKey, nextHandles) }) : state;
+    }
+    case actions.ActionTypes.REGISTER_PROP_CONTROLLERS: {
+      const { documentKey, elementKey, propControllers } = action.payload;
+      return __spreadProps(__spreadValues({}, state), {
+        instances: new Map(state.instances).set(documentKey, new Map((_c = state.instances.get(documentKey)) != null ? _c : []).set(elementKey, propControllers))
+      });
+    }
+    case actions.ActionTypes.UNREGISTER_PROP_CONTROLLERS: {
+      const { documentKey, elementKey } = action.payload;
+      const nextInstances = new Map((_d = state.instances.get(documentKey)) != null ? _d : []);
+      const deleted = nextInstances.delete(elementKey);
+      return deleted ? __spreadProps(__spreadValues({}, state), { instances: new Map(state.instances).set(documentKey, nextInstances) }) : state;
+    }
+    default:
+      return state;
+  }
+}
+function getInitialState$3() {
+  return false;
+}
+function reducer$4(state = getInitialState$3(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.SET_IS_IN_BUILDER:
+      return action.payload;
+    default:
+      return state;
+  }
+}
+function getInitialState$2(isPreview = false) {
+  return isPreview;
+}
+function getIsPreview$1(state) {
+  return state;
+}
+function reducer$3(state = getInitialState$2(), action) {
+  switch (action.type) {
+    default:
+      return state;
+  }
+}
 const BuilderEditMode = {
   BUILD: "build",
   CONTENT: "content",
   INTERACT: "interact"
 };
-function getInitialState() {
+function getInitialState$1() {
   return null;
 }
-function reducer(state = getInitialState(), action) {
+function reducer$2(state = getInitialState$1(), action) {
   switch (action.type) {
     case actions.ActionTypes.SET_BUILDER_EDIT_MODE:
       return action.payload.editMode;
@@ -40,6 +258,34 @@ function reducer(state = getInitialState(), action) {
       return state;
   }
 }
+function getInitialState(initialState) {
+  var _a, _b, _c;
+  return {
+    locales: (_a = initialState == null ? void 0 : initialState.locales) != null ? _a : [],
+    locale: (_b = initialState == null ? void 0 : initialState.locale) != null ? _b : null,
+    defaultLocale: (_c = initialState == null ? void 0 : initialState.defaultLocale) != null ? _c : null
+  };
+}
+function reducer$1(state = getInitialState(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.SET_LOCALES: {
+      const locales = action.payload.locales;
+      return __spreadProps(__spreadValues({}, state), { locales });
+    }
+    case actions.ActionTypes.SET_LOCALE: {
+      if (action.payload.locale === state.locale)
+        return state;
+      return __spreadProps(__spreadValues({}, state), { locale: action.payload.locale });
+    }
+    case actions.ActionTypes.SET_DEFAULT_LOCALE: {
+      if (action.payload.defaultLocale === state.defaultLocale)
+        return state;
+      return __spreadProps(__spreadValues({}, state), { defaultLocale: action.payload.defaultLocale });
+    }
+    default:
+      return state;
+  }
+}
 const ColorControlType = "makeswift::controls::color";
 function Color(config = {}) {
   return { type: ColorControlType, config };
@@ -315,11 +561,11 @@ 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)
   }));
 }
 const ShapeControlType = "makeswift::controls::shape";
@@ -365,11 +611,11 @@ 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);
   }
@@ -597,6 +843,22 @@ function copySlotData(value, context) {
     elements: value.elements.map((element) => context.copyElement(element))
   });
 }
+function mergeSlotData(base = { columns: [], elements: [] }, override = { columns: [], elements: [] }, context) {
+  const mergedColumns = base.columns;
+  const mergedElements = base.elements.flatMap((baseElement) => {
+    const overrideElement = override.elements.find((e) => baseElement.type === e.type && baseElement.key === e.key);
+    if (overrideElement == null)
+      return [baseElement];
+    if (overrideElement.deleted)
+      return [];
+    if (isElementReference(overrideElement))
+      return [overrideElement];
+    if (isElementReference(baseElement))
+      return [baseElement];
+    return context.mergeElement(baseElement, overrideElement);
+  });
+  return { columns: mergedColumns, elements: mergedElements };
+}
 function copy$e(value, context) {
   if (value == null)
     return value;
@@ -1349,8 +1611,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:
@@ -1364,7 +1626,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:
@@ -1372,9 +1634,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:
@@ -1383,6 +1645,18 @@ function copy(definition, value, context) {
       return value;
   }
 }
+function merge(definition2, a, b = a, context) {
+  switch (definition2.type) {
+    case SlotControlType:
+      return mergeSlotData(a, b, context);
+    default:
+      return b;
+  }
+}
+const SelectControlType = "makeswift::controls::select";
+function Select(config) {
+  return { type: SelectControlType, config };
+}
 const ObjectType = {
   Value: "value",
   Text: "text",
@@ -1398,6 +1672,712 @@ const ObjectType = {
   Point: "point",
   Operation: "operation"
 };
+const RootBlockType = {
+  Default: "default",
+  Text: "text-block",
+  Paragraph: "paragraph",
+  Heading1: "heading-one",
+  Heading2: "heading-two",
+  Heading3: "heading-three",
+  Heading4: "heading-four",
+  Heading5: "heading-five",
+  Heading6: "heading-six",
+  BlockQuote: "blockquote",
+  UnorderedList: "unordered-list",
+  OrderedList: "ordered-list"
+};
+const BlockType = __spreadProps(__spreadValues({}, RootBlockType), {
+  ListItem: "list-item",
+  ListItemChild: "list-item-child"
+});
+const InlineType = {
+  Code: "code",
+  SuperScript: "superscript",
+  SubScript: "subscript",
+  Link: "link"
+};
+const BlockTextAlignment = {
+  Left: "left",
+  Center: "center",
+  Right: "right",
+  Justify: "justify"
+};
+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.Text) || 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 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 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 _a;
+  const rootBlocks = getBlocksInSelection(editor).map(([node]) => node.type);
+  return rootBlocks.reduce((a, b) => a === b ? b : null, (_a = rootBlocks.at(0)) != null ? _a : null);
+}
+function setBlockKeyForDevice(editor, breakpoints, deviceId, key, value, options) {
+  var _a, _b;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+  if (!at)
+    return;
+  const rootElements = getBlocksInSelection(editor);
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceValues = (_b = node[key]) != null ? _b : [];
+      const currentDeviceValue = 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 _a;
+  const rootElements = getBlocksInSelection(editor);
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceOverrides = (_a = node[key]) != null ? _a : [];
+      slate.Transforms.setNodes(editor, {
+        [key]: deviceOverrides.filter((v) => v.deviceId !== deviceId)
+      }, { at: path });
+    }
+  }
+}
+function wrapInline(editor, inline) {
+  slate.Transforms.wrapNodes(editor, inline, {
+    at: getSelection(editor),
+    split: true
+  });
+}
+function unwrapInline(editor, type) {
+  slate.Transforms.unwrapNodes(editor, {
+    match: (node) => ElementUtils.isInline(node) && node.type === type,
+    at: getSelection(editor)
+  });
+}
+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 filterForSubtreeRoots(entries) {
+  return entries.filter(([, nodePath]) => !slate.Path.ancestors(nodePath).some((ancestor) => {
+    return entries.some(([, path]) => slate.Path.equals(path, ancestor));
+  }));
+}
+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 _a;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : 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 _a;
+  const at = (_a = options.at) != null ? _a : 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 _a, _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 = (_a = EditorUtils.getFirstAncestorListItem(editor, start)) == null ? void 0 : _a[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 _a;
+  const at = (_a = options.at) != null ? _a : 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 _a;
+    const [normalizationNode, normalizationPath] = entry;
+    if (ElementUtils.isBlock(normalizationNode) && ((_a = normalizationNode == null ? void 0 : normalizationNode.textAlign) == null ? void 0 : _a.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.Text || activeBlock === RootBlockType.Default)
+          return void 0;
+        return activeBlock;
+      }
+    }
+  });
+}
+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: onKeyDown2
+}) {
+  return { control, withPlugin, onKeyDown: onKeyDown2 };
+}
+function unstable_RichTextV2(config = {}) {
+  return { type: RichTextV2ControlType, config };
+}
+const RichTextV2ControlMessageType = {
+  RESET_VALUE: "RESET_VALUE",
+  FOCUS: "FOCUS",
+  RUN_PLUGIN_CONTROL_ACTION: "RUN_PLUGIN_CONTROL_ACTION",
+  SET_DEFAULT_VALUE: "SET_DEFAULT_VALUE",
+  SET_PLUGIN_CONTROL_VALUE: "SET_PLUGIN_CONTROL_VALUE",
+  ON_CHANGE: "ON_CHANGE",
+  SELECT: "SELECT",
+  SWITCH_TO_BUILD_MODE: "SWITCH_TO_BUILD_MODE",
+  CHANGE_BOX_MODEL: "CHANGE_BOX_MODEL"
+};
+class RichTextV2Control extends PropController {
+  constructor(send, descriptor) {
+    super(send);
+    __publicField(this, "editor", null);
+    __publicField(this, "defaultValue", null);
+    __publicField(this, "descriptor");
+    __publicField(this, "recv", (message) => {
+      var _a, _b, _c;
+      if (!this.editor)
+        return;
+      switch (message.type) {
+        case RichTextV2ControlMessageType.FOCUS: {
+          this.editor.focusAndSelectAll();
+          break;
+        }
+        case RichTextV2ControlMessageType.RESET_VALUE: {
+          if (this.defaultValue) {
+            this.editor.selection = null;
+            this.editor.children = this.defaultValue;
+            this.editor.onChange();
+          }
+          break;
+        }
+        case RichTextV2ControlMessageType.RUN_PLUGIN_CONTROL_ACTION: {
+          (_c = (_b = (_a = this.descriptor.config.plugins) == null ? void 0 : _a.at(message.pluginIndex)) == null ? void 0 : _b.control) == null ? void 0 : _c.onChange(this.editor, message.value);
+          break;
+        }
+      }
+    });
+    this.descriptor = descriptor;
+    this.send = send;
+  }
+  setEditor(editor) {
+    var _a, _b, _c;
+    this.editor = editor;
+    this.send({
+      type: RichTextV2ControlMessageType.SET_PLUGIN_CONTROL_VALUE,
+      value: (_c = (_b = (_a = this.descriptor.config) == null ? void 0 : _a.plugins) == null ? void 0 : _b.map((plugin) => {
+        var _a2;
+        return (_a2 = plugin == null ? void 0 : plugin.control) == null ? void 0 : _a2.getValue(editor);
+      })) != null ? _c : []
+    });
+  }
+  setDefaultValue(defaultValue) {
+    this.defaultValue = defaultValue;
+    this.send({ type: RichTextV2ControlMessageType.SET_DEFAULT_VALUE, value: defaultValue });
+  }
+  select() {
+    this.send({ type: RichTextV2ControlMessageType.SELECT });
+  }
+  switchToBuildMode() {
+    this.send({ type: RichTextV2ControlMessageType.SWITCH_TO_BUILD_MODE });
+  }
+  onChange(value) {
+    var _a, _b, _c;
+    const editor = this.editor;
+    if (editor == null)
+      return;
+    this.send({
+      type: RichTextV2ControlMessageType.ON_CHANGE,
+      value
+    });
+    this.send({
+      type: RichTextV2ControlMessageType.SET_PLUGIN_CONTROL_VALUE,
+      value: (_c = (_b = (_a = this.descriptor.config) == null ? void 0 : _a.plugins) == null ? void 0 : _b.map((plugin) => {
+        var _a2;
+        return (_a2 = plugin == null ? void 0 : plugin.control) == null ? void 0 : _a2.getValue(editor);
+      })) != null ? _c : []
+    });
+  }
+  changeBoxModel(boxModel) {
+    this.send({ type: RichTextV2ControlMessageType.CHANGE_BOX_MODEL, payload: { boxModel } });
+  }
+}
 function isText(node) {
   if (typeof node === "object" && "text" in node)
     return true;
@@ -1416,7 +2396,7 @@ function toTextDAO(node) {
 function toInlineDAO(node) {
   var _a, _b, _c, _d;
   switch (node.type) {
-    case slate.InlineType.Link:
+    case InlineType.Link:
       return [
         {
           children: (_b = (_a = node.nodes) == null ? void 0 : _a.flatMap(toInlineOrTextDAO)) != null ? _b : [],
@@ -1424,9 +2404,9 @@ function toInlineDAO(node) {
           type: node.type
         }
       ];
-    case slate.InlineType.Code:
-    case slate.InlineType.SubScript:
-    case slate.InlineType.SuperScript:
+    case InlineType.Code:
+    case InlineType.SubScript:
+    case InlineType.SuperScript:
       return [
         {
           children: (_d = (_c = node.nodes) == null ? void 0 : _c.flatMap(toInlineOrTextDAO)) != null ? _d : [],
@@ -1503,7 +2483,7 @@ function toInlineOrTextDTO(node) {
     ];
   }
   switch (node.type) {
-    case slate.InlineType.Link:
+    case InlineType.Link:
       return [
         {
           object: ObjectType.Inline,
@@ -1512,9 +2492,9 @@ function toInlineOrTextDTO(node) {
           data: node.link
         }
       ];
-    case slate.InlineType.Code:
-    case slate.InlineType.SubScript:
-    case slate.InlineType.SuperScript:
+    case InlineType.Code:
+    case InlineType.SubScript:
+    case InlineType.SuperScript:
       return [
         {
           object: "inline",
@@ -1530,20 +2510,20 @@ function toNodeDTO(node) {
   if (isText(node))
     return toInlineOrTextDTO(node);
   switch (node.type) {
-    case slate.InlineType.Link:
-    case slate.InlineType.Code:
-    case slate.InlineType.SubScript:
-    case slate.InlineType.SuperScript:
+    case InlineType.Link:
+    case InlineType.Code:
+    case InlineType.SubScript:
+    case InlineType.SuperScript:
       return toInlineOrTextDTO(node);
-    case slate.BlockType.Heading1:
-    case slate.BlockType.Heading2:
-    case slate.BlockType.Heading3:
-    case slate.BlockType.BlockQuote:
-    case slate.BlockType.Paragraph:
-    case slate.BlockType.OrderedList:
-    case slate.BlockType.UnorderedList:
-    case slate.BlockType.ListItem:
-    case slate.BlockType.ListItemChild:
+    case BlockType.Heading1:
+    case BlockType.Heading2:
+    case BlockType.Heading3:
+    case BlockType.BlockQuote:
+    case BlockType.Paragraph:
+    case BlockType.OrderedList:
+    case BlockType.UnorderedList:
+    case BlockType.ListItem:
+    case BlockType.ListItemChild:
       return [
         {
           type: node.type,
@@ -1660,72 +2640,6 @@ class RichTextControl extends PropController {
     this.send({ type: RichTextControlMessageType.CHANGE_BOX_MODEL, payload: { boxModel } });
   }
 }
-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 unstable_RichTextV2(config = {}) {
-  return { type: RichTextV2ControlType, config };
-}
-const RichTextV2ControlMessageType = {
-  RESET_VALUE: "RESET_VALUE",
-  FOCUS: "FOCUS",
-  SET_DEFAULT_VALUE: "SET_DEFAULT_VALUE",
-  ON_CHANGE: "ON_CHANGE",
-  SELECT: "SELECT",
-  SWITCH_TO_BUILD_MODE: "SWITCH_TO_BUILD_MODE",
-  CHANGE_BOX_MODEL: "CHANGE_BOX_MODEL"
-};
-class RichTextV2Control extends PropController {
-  constructor(send, descriptor) {
-    super(send);
-    __publicField(this, "editor", null);
-    __publicField(this, "defaultValue", null);
-    __publicField(this, "descriptor");
-    __publicField(this, "recv", (message) => {
-      if (!this.editor)
-        return;
-      switch (message.type) {
-        case RichTextV2ControlMessageType.FOCUS: {
-          this.editor.focusAndSelectAll();
-          break;
-        }
-        case RichTextV2ControlMessageType.RESET_VALUE: {
-          if (this.defaultValue) {
-            this.editor.selection = null;
-            this.editor.children = this.defaultValue;
-            this.editor.onChange();
-          }
-        }
-      }
-    });
-    this.descriptor = descriptor;
-    this.send = send;
-  }
-  setEditor(editor) {
-    this.editor = editor;
-  }
-  setDefaultValue(defaultValue) {
-    this.defaultValue = defaultValue;
-    this.send({ type: RichTextV2ControlMessageType.SET_DEFAULT_VALUE, value: defaultValue });
-  }
-  select() {
-    this.send({ type: RichTextV2ControlMessageType.SELECT });
-  }
-  switchToBuildMode() {
-    this.send({ type: RichTextV2ControlMessageType.SWITCH_TO_BUILD_MODE });
-  }
-  onChange(value) {
-    this.send({
-      type: RichTextV2ControlMessageType.ON_CHANGE,
-      value
-    });
-  }
-  changeBoxModel(boxModel) {
-    this.send({ type: RichTextV2ControlMessageType.CHANGE_BOX_MODEL, payload: { boxModel } });
-  }
-}
 const Types = {
   Backgrounds: "Backgrounds",
   Border: "Border",
@@ -1949,7 +2863,491 @@ var descriptors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   WidthPropControllerFormat,
   Width
 }, Symbol.toStringTag, { value: "Module" }));
+function isNonNullable(value) {
+  return value != null;
+}
+function getElementChildren(descriptor, prop) {
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.Grid:
+      return prop.elements;
+    case SlotControlType:
+      return prop.elements;
+    case ListControlType:
+      return prop.flatMap(({ value }) => getElementChildren(descriptor.config.type, value));
+    case ShapeControlType: {
+      const shapeControlData = prop;
+      return Object.keys(shapeControlData).flatMap((key) => getElementChildren(descriptor.config.type[key], shapeControlData[key]));
+    }
+    default:
+      return [];
+  }
+}
+function getElementId$1(descriptor, prop) {
+  if (prop == null)
+    return null;
+  switch (descriptor.type) {
+    case Types.ElementID:
+      return prop;
+    default:
+      return null;
+  }
+}
+function getBackgroundsSwatchIds(value) {
+  var _a;
+  return (_a = value == null ? void 0 : value.flatMap((override) => override.value).flatMap((backgroundItem) => {
+    var _a2;
+    switch (backgroundItem.type) {
+      case "color":
+        return ((_a2 = backgroundItem.payload) == null ? void 0 : _a2.swatchId) == null ? [] : [backgroundItem.payload.swatchId];
+      case "gradient":
+        return backgroundItem.payload.stops.flatMap((stop) => stop.color == null ? [] : stop.color.swatchId);
+      default:
+        return [];
+    }
+  })) != null ? _a : [];
+}
+function getBorderSwatchIds(value) {
+  var _a;
+  return (_a = value == null ? void 0 : value.flatMap((override) => override.value).flatMap((borderValue) => {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
+    return [
+      (_b = (_a2 = borderValue.borderTop) == null ? void 0 : _a2.color) == null ? void 0 : _b.swatchId,
+      (_d = (_c = borderValue.borderRight) == null ? void 0 : _c.color) == null ? void 0 : _d.swatchId,
+      (_f = (_e = borderValue.borderBottom) == null ? void 0 : _e.color) == null ? void 0 : _f.swatchId,
+      (_h = (_g = borderValue.borderLeft) == null ? void 0 : _g.color) == null ? void 0 : _h.swatchId
+    ].filter((swatchId) => swatchId != null);
+  })) != null ? _a : [];
+}
+function getBoxShadowsSwatchIds(value) {
+  var _a;
+  return (_a = value == null ? void 0 : value.flatMap((override) => override.value).map((item) => {
+    var _a2;
+    return (_a2 = item.payload.color) == null ? void 0 : _a2.swatchId;
+  }).filter((swatchId) => swatchId != null)) != null ? _a : [];
+}
+function getResponsiveColorSwatchIds(value) {
+  var _a;
+  return (_a = value == null ? void 0 : value.map((override) => override.value).map((color) => color.swatchId)) != null ? _a : [];
+}
+function getTypographyStyleSwatchIds(style) {
+  var _a;
+  return (_a = style == null ? void 0 : style.map((override) => override.value).flatMap((typographyStyle) => {
+    var _a2;
+    return (_a2 = typographyStyle.color) == null ? void 0 : _a2.swatchId;
+  }).filter(isNonNullable)) != null ? _a : [];
+}
+function getElementSwatchIds(descriptor, prop) {
+  var _a;
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.Backgrounds:
+      return getBackgroundsSwatchIds(prop);
+    case Types.Border:
+      return getBorderSwatchIds(prop);
+    case Types.NavigationLinks: {
+      const value = prop;
+      return (_a = value == null ? void 0 : value.flatMap((item) => {
+        var _a2, _b, _c, _d;
+        switch (item.type) {
+          case "button":
+          case "dropdown":
+            return [
+              ...(_b = (_a2 = item.payload.color) == null ? void 0 : _a2.map((override) => override.value).map((color) => color.swatchId)) != null ? _b : [],
+              ...(_d = (_c = item.payload.textColor) == null ? void 0 : _c.map((override) => override.value).map((color) => color.swatchId)) != null ? _d : []
+            ];
+        }
+      })) != null ? _a : [];
+    }
+    case Types.ResponsiveColor:
+      return getResponsiveColorSwatchIds(prop);
+    case Types.Shadows:
+      return getBoxShadowsSwatchIds(prop);
+    case Types.RichText: {
+      let getNodeSwatchIds = function(node) {
+        var _a2, _b, _c, _d;
+        switch (node.object) {
+          case "document":
+          case "block":
+          case "inline":
+            return (_b = (_a2 = node.nodes) == null ? void 0 : _a2.flatMap(getNodeSwatchIds)) != null ? _b : [];
+          case "text":
+            return (_d = (_c = node.marks) == null ? void 0 : _c.flatMap(getMarkSwatchIds)) != null ? _d : [];
+          default:
+            return [];
+        }
+      }, getMarkSwatchIds = function(mark) {
+        var _a2, _b;
+        return getTypographyStyleSwatchIds((_b = (_a2 = mark.data) == null ? void 0 : _a2.value) == null ? void 0 : _b.style);
+      };
+      const value = prop;
+      if (value == null || value.document == null)
+        return [];
+      return getNodeSwatchIds(value.document);
+    }
+    case ColorControlType: {
+      const value = prop;
+      return (value == null ? void 0 : value.swatchId) == null ? [] : [value.swatchId];
+    }
+    default:
+      return [];
+  }
+}
+function getBackgroundsFileIds(value) {
+  var _a;
+  return (_a = value == null ? void 0 : value.flatMap((override) => override.value).flatMap((backgroundItem) => {
+    switch (backgroundItem.type) {
+      case "image":
+        return [backgroundItem.payload.imageId];
+      default:
+        return [];
+    }
+  })) != null ? _a : [];
+}
+function getFileIds(descriptor, prop) {
+  var _a;
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.Backgrounds:
+      return getBackgroundsFileIds(prop);
+    case Types.Image: {
+      const value = prop;
+      return value == null ? [] : [value];
+    }
+    case Types.Images: {
+      const value = prop;
+      return (_a = value == null ? void 0 : value.flatMap((item) => item.props.file == null ? [] : [item.props.file])) != null ? _a : [];
+    }
+    case ImageControlType: {
+      const value = prop;
+      return value == null ? [] : [value];
+    }
+    default:
+      return [];
+  }
+}
+function getTypographyIds(descriptor, prop) {
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.RichText: {
+      let getNodeTypographyIds = function(node) {
+        var _a, _b, _c, _d;
+        switch (node.object) {
+          case "document":
+          case "block":
+          case "inline":
+            return (_b = (_a = node.nodes) == null ? void 0 : _a.flatMap(getNodeTypographyIds)) != null ? _b : [];
+          case "text":
+            return (_d = (_c = node.marks) == null ? void 0 : _c.flatMap(getMarkTypographyIds)) != null ? _d : [];
+          default:
+            return [];
+        }
+      }, getMarkTypographyIds = function(mark) {
+        var _a, _b;
+        return [(_b = (_a = mark.data) == null ? void 0 : _a.value) == null ? void 0 : _b.id].filter((id) => id != null);
+      };
+      const value = prop;
+      if (value == null || value.document == null)
+        return [];
+      return getNodeTypographyIds(value.document);
+    }
+    default:
+      return [];
+  }
+}
+function getTableIds(descriptor, prop) {
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.Table: {
+      const value = prop;
+      return value == null ? [] : [value];
+    }
+    default:
+      return [];
+  }
+}
+function getPageIds(descriptor, prop) {
+  var _a;
+  if (prop == null)
+    return [];
+  switch (descriptor.type) {
+    case Types.Link: {
+      const value = prop;
+      if (value == null)
+        return [];
+      switch (value.type) {
+        case "OPEN_PAGE":
+          return value.payload.pageId == null ? [] : [value.payload.pageId];
+        default:
+          return [];
+      }
+    }
+    case Types.NavigationLinks: {
+      const value = prop;
+      if (value == null)
+        return [];
+      return (_a = value == null ? void 0 : value.flatMap((item) => {
+        var _a2, _b;
+        switch (item.type) {
+          case "button": {
+            if (item.payload.link == null)
+              return [];
+            switch (item.payload.link.type) {
+              case "OPEN_PAGE":
+                return item.payload.link.payload.pageId == null ? [] : [item.payload.link.payload.pageId];
+              default:
+                return [];
+            }
+          }
+          case "dropdown": {
+            return (_b = (_a2 = item.payload.links) == null ? void 0 : _a2.flatMap((link) => {
+              if (link.payload.link == null)
+                return [];
+              switch (link.payload.link.type) {
+                case "OPEN_PAGE":
+                  return link.payload.link.payload.pageId == null ? [] : [link.payload.link.payload.pageId];
+                default:
+                  return [];
+              }
+            })) != null ? _b : [];
+          }
+        }
+      })) != null ? _a : [];
+    }
+    case Types.RichText: {
+      let getNodePageIds = function(node) {
+        var _a2, _b;
+        switch (node.object) {
+          case "document":
+          case "block":
+            return (_b = (_a2 = node.nodes) == null ? void 0 : _a2.flatMap(getNodePageIds)) != null ? _b : [];
+          case "inline":
+            return getInlinePageIds(node);
+          default:
+            return [];
+        }
+      }, getInlinePageIds = function(inline) {
+        var _a2, _b, _c, _d;
+        switch (inline.type) {
+          case "link": {
+            const nodePageIds = (_b = (_a2 = inline.nodes) == null ? void 0 : _a2.flatMap(getNodePageIds)) != null ? _b : [];
+            const dataPageIds = inline.data ? getLinkDataPageIds(inline.data) : [];
+            return [...nodePageIds, ...dataPageIds];
+          }
+          default:
+            return (_d = (_c = inline.nodes) == null ? void 0 : _c.flatMap(getNodePageIds)) != null ? _d : [];
+        }
+      }, getLinkDataPageIds = function(link) {
+        switch (link.type) {
+          case "OPEN_PAGE":
+            return link.payload.pageId == null ? [] : [link.payload.pageId];
+          default:
+            return [];
+        }
+      };
+      const value = prop;
+      if (value == null || value.document == null)
+        return [];
+      return getNodePageIds(value.document);
+    }
+    default:
+      return [];
+  }
+}
+var introspection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getElementChildren,
+  getElementId: getElementId$1,
+  getBackgroundsSwatchIds,
+  getBorderSwatchIds,
+  getBoxShadowsSwatchIds,
+  getResponsiveColorSwatchIds,
+  getTypographyStyleSwatchIds,
+  getElementSwatchIds,
+  getBackgroundsFileIds,
+  getFileIds,
+  getTypographyIds,
+  getTableIds,
+  getPageIds
+}, Symbol.toStringTag, { value: "Module" }));
+const reducer = redux.combineReducers({
+  documents: reducer$8,
+  reactComponents: reducer$7,
+  componentsMeta: reducer$9,
+  propControllers: reducer$6,
+  propControllerHandles: reducer$5,
+  isInBuilder: reducer$4,
+  isPreview: reducer$3,
+  builderEditMode: reducer$2,
+  breakpoints: state_breakpoints.reducer,
+  locales: reducer$1
+});
+function getDocumentsStateSlice(state) {
+  return state.documents;
+}
+function getDocument(state, documentKey) {
+  return getDocument$1(getDocumentsStateSlice(state), documentKey);
+}
+function getReactComponentsStateSlice(state) {
+  return state.reactComponents;
+}
+function getReactComponent(state, type) {
+  return getReactComponent$1(getReactComponentsStateSlice(state), type);
+}
+function getPropControllersStateSlice(state) {
+  return state.propControllers;
+}
+function getPropControllerDescriptors(state) {
+  return getPropControllerDescriptors$1(getPropControllersStateSlice(state));
+}
+function getComponentPropControllerDescriptors(state, componentType) {
+  return getComponentPropControllerDescriptors$1(getPropControllersStateSlice(state), componentType);
+}
+function getPropControllerHandlesStateSlice(state) {
+  return state.propControllerHandles;
+}
+function getPropControllers(state, documentKey, elementKey) {
+  return getPropControllers$1(getPropControllerHandlesStateSlice(state), documentKey, elementKey);
+}
+function normalizeElement(element, descriptors2) {
+  const elements = /* @__PURE__ */ new Map();
+  const remaining = [element];
+  let current;
+  while (current = remaining.pop()) {
+    elements.set(current.key, current);
+    if (isElementReference(current))
+      continue;
+    const elementDescriptors = descriptors2.get(current.type);
+    if (elementDescriptors == null)
+      continue;
+    const parent = current;
+    const children = Object.entries(elementDescriptors).reduce((acc, [propName, descriptor]) => {
+      return [...acc, ...getElementChildren(descriptor, parent.props[propName])];
+    }, []);
+    remaining.push(...children);
+  }
+  return elements;
+}
+function getDocumentElements(state, documentKey) {
+  const document = getDocument(state, documentKey);
+  const descriptors2 = getPropControllerDescriptors(state);
+  if (document == null)
+    return /* @__PURE__ */ new Map();
+  return normalizeElement(document.rootElement, descriptors2);
+}
+function getDocumentKeysSortedByDepth(state) {
+  const documents = getDocuments(getDocumentsStateSlice(state));
+  const keys = Array.from(documents.keys());
+  if (keys.length < 2)
+    return keys;
+  const elements = /* @__PURE__ */ new Map();
+  keys.forEach((key) => {
+    elements.set(key, getDocumentElements(state, key));
+  });
+  keys.sort((a, b) => {
+    var _a;
+    return ((_a = elements.get(a)) == null ? void 0 : _a.has(b)) ? -1 : 1;
+  });
+  return keys;
+}
+function getElement(state, documentKey, elementKey) {
+  var _a;
+  return (_a = getDocumentElements(state, documentKey).get(elementKey)) != null ? _a : null;
+}
+function getElementPropControllerDescriptors(state, documentKey, elementKey) {
+  const element = getElement(state, documentKey, elementKey);
+  if (element == null || isElementReference(element))
+    return null;
+  return getComponentPropControllerDescriptors(state, element.type);
+}
+function getElementId(state, documentKey, elementKey) {
+  const element = getElement(state, documentKey, elementKey);
+  if (element == null || isElementReference(element))
+    return null;
+  const descriptors2 = getComponentPropControllerDescriptors(state, element.type);
+  if (descriptors2 == null)
+    return null;
+  const elementId = Object.entries(descriptors2).reduce((acc, [propName, descriptor]) => {
+    if (acc != null)
+      return acc;
+    return getElementId$1(descriptor, element.props[propName]);
+  }, null);
+  return elementId;
+}
+function createReplacementContext(serializableReplacementContext) {
+  const rc = {
+    elementHtmlIds: new Set(serializableReplacementContext.elementHtmlIds),
+    elementKeys: new Map(serializableReplacementContext.elementKeys && Object.entries(serializableReplacementContext.elementKeys)),
+    swatchIds: new Map(serializableReplacementContext.swatchIds && Object.entries(serializableReplacementContext.swatchIds)),
+    fileIds: new Map(serializableReplacementContext.fileIds && Object.entries(serializableReplacementContext.fileIds)),
+    typographyIds: new Map(serializableReplacementContext.typographyIds && Object.entries(serializableReplacementContext.typographyIds)),
+    tableIds: new Map(serializableReplacementContext.tableIds && Object.entries(serializableReplacementContext.tableIds)),
+    tableColumnIds: new Map(serializableReplacementContext.tableColumnIds && Object.entries(serializableReplacementContext.tableColumnIds)),
+    pageIds: new Map(serializableReplacementContext.pageIds && Object.entries(serializableReplacementContext.pageIds)),
+    globalElementIds: new Map(serializableReplacementContext.globalElementIds && Object.entries(serializableReplacementContext.globalElementIds)),
+    globalElementData: new Map(serializableReplacementContext.globalElementData && Object.entries(serializableReplacementContext.globalElementData))
+  };
+  return rc;
+}
+function copyElementTree(state, elementTree, replacementContext) {
+  function copyElementTreeNode(state2, replacementContext2) {
+    return function(node) {
+      const context = {
+        replacementContext: replacementContext2,
+        copyElement: copyElementTreeNode(state2, replacementContext2)
+      };
+      if (isElementReference(node)) {
+        return __spreadProps(__spreadValues({}, node), { value: copyElementReference(node.value, context) });
+      }
+      const descriptors2 = getComponentPropControllerDescriptors(state2, node.type);
+      if (descriptors2 == null)
+        return node;
+      for (const [propKey, descriptor] of Object.entries(descriptors2)) {
+        node.props[propKey] = copy(descriptor, node.props[propKey], context);
+      }
+      return node;
+    };
+  }
+  const copy$12 = JSON.parse(JSON.stringify(elementTree));
+  return copyElementTreeNode(state, createReplacementContext(replacementContext))(copy$12);
+}
+function getIsInBuilder(state) {
+  return state.isInBuilder;
+}
+function getIsPreview(state) {
+  return getIsPreview$1(state.isPreview);
+}
+function getBuilderEditMode(state) {
+  return state.builderEditMode;
+}
+function getBreakpoints(state) {
+  return state.breakpoints;
+}
+function getLocales(state) {
+  return state.locales;
+}
+function configureStore({
+  rootElements,
+  preloadedState,
+  breakpoints,
+  locales
+} = {}) {
+  return redux.createStore(reducer, __spreadProps(__spreadValues({}, preloadedState), {
+    documents: getInitialState$7({ rootElements }),
+    breakpoints: state_breakpoints.getInitialState(breakpoints != null ? breakpoints : preloadedState == null ? void 0 : preloadedState.breakpoints),
+    locales: getInitialState(locales != null ? locales : preloadedState == null ? void 0 : preloadedState.locales)
+  }), redux.applyMiddleware(thunk__default["default"]));
+}
 exports.Backgrounds = Backgrounds;
+exports.BlockActions = BlockActions;
+exports.BlockPlugin = BlockPlugin;
+exports.BlockTextAlignment = BlockTextAlignment;
+exports.BlockType = BlockType;
 exports.Border = Border;
 exports.BorderPropControllerFormat = BorderPropControllerFormat;
 exports.BorderRadius = BorderRadius;
@@ -1958,8 +3356,10 @@ exports.BuilderEditMode = BuilderEditMode;
 exports.Checkbox = Checkbox;
 exports.Color = Color;
 exports.ColorControlType = ColorControlType;
+exports.ComponentIcon = ComponentIcon;
 exports.Date = Date;
 exports.ElementID = ElementID;
+exports.ElementUtils = ElementUtils;
 exports.Font = Font;
 exports.GapX = GapX;
 exports.GapY = GapY;
@@ -1969,10 +3369,12 @@ exports.Image$1 = Image$1;
 exports.ImageControlType = ImageControlType;
 exports.ImageControlValueFormat = ImageControlValueFormat;
 exports.Images = Images;
+exports.InlineType = InlineType;
 exports.Link = Link;
 exports.Link$1 = Link$1;
 exports.LinkControlType = LinkControlType;
 exports.List = List$1;
+exports.ListActions = ListActions;
 exports.ListControl = ListControl;
 exports.ListControlMessageType = ListControlMessageType;
 exports.ListControlType = ListControlType;
@@ -1999,6 +3401,9 @@ exports.RichTextV2Control = RichTextV2Control;
 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$1;
@@ -2025,21 +3430,73 @@ exports.Types = Types;
 exports.Video = Video;
 exports.Width = Width;
 exports.WidthPropControllerFormat = WidthPropControllerFormat;
+exports.configureStore = configureStore;
 exports.copy = copy;
 exports.copyColorData = copyColorData;
-exports.copyElementReference = copyElementReference;
+exports.copyElementTree = copyElementTree;
 exports.copyImageData = copyImageData;
 exports.copyLinkData = copyLinkData;
 exports.copyListData = copyListData;
 exports.copyShapeData = copyShapeData;
 exports.copySlotData = copySlotData;
 exports.copyStyleData = copyStyleData;
+exports.createDocument = createDocument;
+exports.createDocumentReference = createDocumentReference;
 exports.createPropController = createPropController;
+exports.createRichTextV2Plugin = createRichTextV2Plugin;
 exports.descriptors = descriptors;
-exports.reducer = reducer;
+exports.getBackgroundsFileIds = getBackgroundsFileIds;
+exports.getBackgroundsSwatchIds = getBackgroundsSwatchIds;
+exports.getBorderSwatchIds = getBorderSwatchIds;
+exports.getBoxShadowsSwatchIds = getBoxShadowsSwatchIds;
+exports.getBreakpoints = getBreakpoints;
+exports.getBuilderEditMode = getBuilderEditMode;
+exports.getComponentPropControllerDescriptors = getComponentPropControllerDescriptors;
+exports.getComponentPropControllerDescriptors$1 = getComponentPropControllerDescriptors$1;
+exports.getComponentsMeta = getComponentsMeta;
+exports.getDocument = getDocument;
+exports.getDocument$1 = getDocument$1;
+exports.getDocumentKeysSortedByDepth = getDocumentKeysSortedByDepth;
+exports.getElement = getElement;
+exports.getElementChildren = getElementChildren;
+exports.getElementId = getElementId;
+exports.getElementPropControllerDescriptors = getElementPropControllerDescriptors;
+exports.getElementSwatchIds = getElementSwatchIds;
+exports.getFileIds = getFileIds;
+exports.getInitialState = getInitialState$7;
+exports.getInitialState$1 = getInitialState$2;
+exports.getIsInBuilder = getIsInBuilder;
+exports.getIsPreview = getIsPreview;
+exports.getLocales = getLocales;
+exports.getPageIds = getPageIds;
+exports.getPropController = getPropController;
+exports.getPropControllerDescriptors = getPropControllerDescriptors;
+exports.getPropControllers = getPropControllers;
+exports.getPropControllersHandle = getPropControllersHandle;
+exports.getReactComponent = getReactComponent;
+exports.getResponsiveColorSwatchIds = getResponsiveColorSwatchIds;
+exports.getTableIds = getTableIds;
+exports.getTypographyIds = getTypographyIds;
+exports.introspection = introspection;
+exports.isElementReference = isElementReference;
+exports.isNonNullable = isNonNullable;
+exports.isPropControllersHandle = isPropControllersHandle;
+exports.merge = merge;
+exports.mergeSlotData = mergeSlotData;
+exports.onKeyDown = onKeyDown;
+exports.reducer = reducer$8;
+exports.reducer$1 = reducer$7;
+exports.reducer$2 = reducer$9;
+exports.reducer$3 = reducer$6;
+exports.reducer$4 = reducer$5;
+exports.reducer$5 = reducer$4;
+exports.reducer$6 = reducer$3;
+exports.reducer$7 = reducer$2;
+exports.reducer$8 = reducer$1;
 exports.richTextDAOToDTO = richTextDAOToDTO;
 exports.richTextDTOtoDAO = richTextDTOtoDAO;
 exports.richTextDTOtoSelection = richTextDTOtoSelection;
 exports.toSelectionDTO = toSelectionDTO;
 exports.unstable_RichTextV2 = unstable_RichTextV2;
-//# sourceMappingURL=descriptors.cjs.js.map
+exports.withBlock = withBlock;
+//# sourceMappingURL=react-page.cjs.js.map