@zipify/wysiwyg 3.1.0-0 → 3.1.0-2

package/dist/wysiwyg.mjs

@@ -26,7 +26,7 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _buildDecorations, buildDecorations_fn, _domParser, _parser, _NodeFilter, NodeFilter_get, _Node, Node_get, _removeComments, removeComments_fn, _normalizeRootTags, normalizeRootTags_fn, _createNodeIterator, createNodeIterator_fn, _iterateNodes, iterateNodes_fn, _runIterator, runIterator_fn, _removeEmptyNodes, removeEmptyNodes_fn, _normalizeListItems, normalizeListItems_fn, _isBlockNode, isBlockNode_fn, _isRootNode, isRootNode_fn, _assignElementProperties, assignElementProperties_fn, _removeStyleProperties, removeStyleProperties_fn, _normalizeBreakLines, normalizeBreakLines_fn, _normalizeBlockTextDecoration, normalizeBlockTextDecoration_fn, _moveTextDecorationToChildren, moveTextDecorationToChildren_fn, _parseTextDecoration, parseTextDecoration_fn, _normalizeBlockBackgroundColor, normalizeBlockBackgroundColor_fn, _moveBackgroundColorToChildren, moveBackgroundColorToChildren_fn, _wrapTextNode, wrapTextNode_fn, _iterateNodes2, iterateNodes_fn2, _iterateChildNodes, iterateChildNodes_fn, _bubbleMarks, bubbleMarks_fn, _canBubbleMark, canBubbleMark_fn, _includesMark, includesMark_fn, _includesMarkType, includesMarkType_fn, _removeMark, removeMark_fn, _addMark, addMark_fn, _findMarkIndexByType, findMarkIndexByType_fn, _buildHtml, buildHtml_fn, _buildJson, buildJson_fn, _schema, _domParser2, _nodeDomParser, _textBlock, textBlock_fn, _normalizeTextBlockArgs, normalizeTextBlockArgs_fn, _contentSerializer, _getWeights, getWeights_fn;
+var _buildDecorations, buildDecorations_fn, _domParser, _parser, _NodeFilter, NodeFilter_get, _Node, Node_get, _removeComments, removeComments_fn, _normalizeRootTags, normalizeRootTags_fn, _createNodeIterator, createNodeIterator_fn, _iterateNodes, iterateNodes_fn, _runIterator, runIterator_fn, _removeEmptyNodes, removeEmptyNodes_fn, _normalizeListItems, normalizeListItems_fn, _isBlockNode, isBlockNode_fn, _isRootNode, isRootNode_fn, _assignElementProperties, assignElementProperties_fn, _removeStyleProperties, removeStyleProperties_fn, _normalizeBreakLines, normalizeBreakLines_fn, _normalizeBlockTextDecoration, normalizeBlockTextDecoration_fn, _moveTextDecorationToChildren, moveTextDecorationToChildren_fn, _parseTextDecoration, parseTextDecoration_fn, _normalizeBlockBackgroundColor, normalizeBlockBackgroundColor_fn, _moveBackgroundColorToChildren, moveBackgroundColorToChildren_fn, _wrapTextNode, wrapTextNode_fn, _iterateNodes2, iterateNodes_fn2, _iterateChildNodes, iterateChildNodes_fn, _bubbleMarks, bubbleMarks_fn, _canBubbleMark, canBubbleMark_fn, _includesMark, includesMark_fn, _includesMarkType, includesMarkType_fn, _removeMark, removeMark_fn, _addMark, addMark_fn, _findMarkIndexByType, findMarkIndexByType_fn, _buildHtml, buildHtml_fn, _buildJson, buildJson_fn, _schema, _domParser2, _nodeDomParser, _textBlock, textBlock_fn, _normalizeTextBlockArgs, normalizeTextBlockArgs_fn, _contentSerializer, _baseClass, _makeVariable, _linkPresetId, _makeInternalVariableName, makeInternalVariableName_fn, _getWeights, getWeights_fn;
 import { computed, unref, toRef, reactive, watch, ref, inject, nextTick, onUnmounted, provide, onMounted } from "vue";
 import { ColorModel, ZipifyColorPicker } from "@zipify/colorpicker";
 function OrderedMap(content) {
@@ -12951,1423 +12951,1397 @@ class JsonSerializer {
     return JSON.stringify(json);
   }
 }
-const FontFamily = Mark.create({
-  name: TextSettings.FONT_FAMILY,
-  group: MarkGroups.SETTINGS,
-  addOptions: () => ({
-    fonts: []
-  }),
-  addAttributes: () => ({
-    value: { required: true }
-  }),
-  addCommands() {
-    return {
-      applyFontFamily: createCommand(({ commands: commands2 }, value) => {
-        commands2.applyMark(this.name, { value });
-        const font = commands2.findFontByName(value);
-        let fontWeight = unref(commands2.getFontWeight());
-        if (!font.isWeightSupported(fontWeight)) {
-          fontWeight = font.findClosestWeight(fontWeight);
-          commands2.applyFontWeight(fontWeight);
+const Text$1 = Node.create({
+  name: "text",
+  group: "inline"
+});
+var GOOD_LEAF_SIZE = 200;
+var RopeSequence = function RopeSequence2() {
+};
+RopeSequence.prototype.append = function append(other) {
+  if (!other.length) {
+    return this;
+  }
+  other = RopeSequence.from(other);
+  return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
+};
+RopeSequence.prototype.prepend = function prepend(other) {
+  if (!other.length) {
+    return this;
+  }
+  return RopeSequence.from(other).append(this);
+};
+RopeSequence.prototype.appendInner = function appendInner(other) {
+  return new Append(this, other);
+};
+RopeSequence.prototype.slice = function slice(from2, to) {
+  if (from2 === void 0)
+    from2 = 0;
+  if (to === void 0)
+    to = this.length;
+  if (from2 >= to) {
+    return RopeSequence.empty;
+  }
+  return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
+};
+RopeSequence.prototype.get = function get(i) {
+  if (i < 0 || i >= this.length) {
+    return void 0;
+  }
+  return this.getInner(i);
+};
+RopeSequence.prototype.forEach = function forEach(f, from2, to) {
+  if (from2 === void 0)
+    from2 = 0;
+  if (to === void 0)
+    to = this.length;
+  if (from2 <= to) {
+    this.forEachInner(f, from2, to, 0);
+  } else {
+    this.forEachInvertedInner(f, from2, to, 0);
+  }
+};
+RopeSequence.prototype.map = function map(f, from2, to) {
+  if (from2 === void 0)
+    from2 = 0;
+  if (to === void 0)
+    to = this.length;
+  var result = [];
+  this.forEach(function(elt, i) {
+    return result.push(f(elt, i));
+  }, from2, to);
+  return result;
+};
+RopeSequence.from = function from(values2) {
+  if (values2 instanceof RopeSequence) {
+    return values2;
+  }
+  return values2 && values2.length ? new Leaf(values2) : RopeSequence.empty;
+};
+var Leaf = /* @__PURE__ */ function(RopeSequence3) {
+  function Leaf2(values2) {
+    RopeSequence3.call(this);
+    this.values = values2;
+  }
+  if (RopeSequence3)
+    Leaf2.__proto__ = RopeSequence3;
+  Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Leaf2.prototype.constructor = Leaf2;
+  var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
+  Leaf2.prototype.flatten = function flatten() {
+    return this.values;
+  };
+  Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
+      return this;
+    }
+    return new Leaf2(this.values.slice(from2, to));
+  };
+  Leaf2.prototype.getInner = function getInner(i) {
+    return this.values[i];
+  };
+  Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    for (var i = from2; i < to; i++) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    for (var i = from2 - 1; i >= to; i--) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.leafAppend = function leafAppend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(this.values.concat(other.flatten()));
+    }
+  };
+  Leaf2.prototype.leafPrepend = function leafPrepend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(other.flatten().concat(this.values));
+    }
+  };
+  prototypeAccessors.length.get = function() {
+    return this.values.length;
+  };
+  prototypeAccessors.depth.get = function() {
+    return 0;
+  };
+  Object.defineProperties(Leaf2.prototype, prototypeAccessors);
+  return Leaf2;
+}(RopeSequence);
+RopeSequence.empty = new Leaf([]);
+var Append = /* @__PURE__ */ function(RopeSequence3) {
+  function Append2(left, right) {
+    RopeSequence3.call(this);
+    this.left = left;
+    this.right = right;
+    this.length = left.length + right.length;
+    this.depth = Math.max(left.depth, right.depth) + 1;
+  }
+  if (RopeSequence3)
+    Append2.__proto__ = RopeSequence3;
+  Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Append2.prototype.constructor = Append2;
+  Append2.prototype.flatten = function flatten() {
+    return this.left.flatten().concat(this.right.flatten());
+  };
+  Append2.prototype.getInner = function getInner(i) {
+    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
+  };
+  Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
+      return false;
+    }
+    if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+    if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
+      return this;
+    }
+    var leftLen = this.left.length;
+    if (to <= leftLen) {
+      return this.left.slice(from2, to);
+    }
+    if (from2 >= leftLen) {
+      return this.right.slice(from2 - leftLen, to - leftLen);
+    }
+    return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
+  };
+  Append2.prototype.leafAppend = function leafAppend(other) {
+    var inner = this.right.leafAppend(other);
+    if (inner) {
+      return new Append2(this.left, inner);
+    }
+  };
+  Append2.prototype.leafPrepend = function leafPrepend(other) {
+    var inner = this.left.leafPrepend(other);
+    if (inner) {
+      return new Append2(inner, this.right);
+    }
+  };
+  Append2.prototype.appendInner = function appendInner2(other) {
+    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
+      return new Append2(this.left, new Append2(this.right, other));
+    }
+    return new Append2(this, other);
+  };
+  return Append2;
+}(RopeSequence);
+var ropeSequence = RopeSequence;
+const max_empty_items = 500;
+class Branch {
+  constructor(items, eventCount) {
+    this.items = items;
+    this.eventCount = eventCount;
+  }
+  popEvent(state, preserveItems) {
+    if (this.eventCount == 0)
+      return null;
+    let end = this.items.length;
+    for (; ; end--) {
+      let next2 = this.items.get(end - 1);
+      if (next2.selection) {
+        --end;
+        break;
+      }
+    }
+    let remap, mapFrom;
+    if (preserveItems) {
+      remap = this.remapping(end, this.items.length);
+      mapFrom = remap.maps.length;
+    }
+    let transform = state.tr;
+    let selection, remaining;
+    let addAfter = [], addBefore = [];
+    this.items.forEach((item, i) => {
+      if (!item.step) {
+        if (!remap) {
+          remap = this.remapping(end, i + 1);
+          mapFrom = remap.maps.length;
         }
-        if (!font.isItalicSupported(fontWeight)) {
-          commands2.removeItalic();
+        mapFrom--;
+        addBefore.push(item);
+        return;
+      }
+      if (remap) {
+        addBefore.push(new Item(item.map));
+        let step = item.step.map(remap.slice(mapFrom)), map2;
+        if (step && transform.maybeStep(step).doc) {
+          map2 = transform.mapping.maps[transform.mapping.maps.length - 1];
+          addAfter.push(new Item(map2, void 0, void 0, addAfter.length + addBefore.length));
+        }
+        mapFrom--;
+        if (map2)
+          remap.appendMap(map2, mapFrom);
+      } else {
+        transform.maybeStep(item.step);
+      }
+      if (item.selection) {
+        selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
+        remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
+        return false;
+      }
+    }, this.items.length, 0);
+    return { remaining, transform, selection };
+  }
+  addTransform(transform, selection, histOptions, preserveItems) {
+    let newItems = [], eventCount = this.eventCount;
+    let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
+    for (let i = 0; i < transform.steps.length; i++) {
+      let step = transform.steps[i].invert(transform.docs[i]);
+      let item = new Item(transform.mapping.maps[i], step, selection), merged;
+      if (merged = lastItem && lastItem.merge(item)) {
+        item = merged;
+        if (i)
+          newItems.pop();
+        else
+          oldItems = oldItems.slice(0, oldItems.length - 1);
+      }
+      newItems.push(item);
+      if (selection) {
+        eventCount++;
+        selection = void 0;
+      }
+      if (!preserveItems)
+        lastItem = item;
+    }
+    let overflow = eventCount - histOptions.depth;
+    if (overflow > DEPTH_OVERFLOW) {
+      oldItems = cutOffEvents(oldItems, overflow);
+      eventCount -= overflow;
+    }
+    return new Branch(oldItems.append(newItems), eventCount);
+  }
+  remapping(from2, to) {
+    let maps = new Mapping();
+    this.items.forEach((item, i) => {
+      let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from2 ? maps.maps.length - item.mirrorOffset : void 0;
+      maps.appendMap(item.map, mirrorPos);
+    }, from2, to);
+    return maps;
+  }
+  addMaps(array) {
+    if (this.eventCount == 0)
+      return this;
+    return new Branch(this.items.append(array.map((map2) => new Item(map2))), this.eventCount);
+  }
+  rebased(rebasedTransform, rebasedCount) {
+    if (!this.eventCount)
+      return this;
+    let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
+    let mapping = rebasedTransform.mapping;
+    let newUntil = rebasedTransform.steps.length;
+    let eventCount = this.eventCount;
+    this.items.forEach((item) => {
+      if (item.selection)
+        eventCount--;
+    }, start);
+    let iRebased = rebasedCount;
+    this.items.forEach((item) => {
+      let pos = mapping.getMirror(--iRebased);
+      if (pos == null)
+        return;
+      newUntil = Math.min(newUntil, pos);
+      let map2 = mapping.maps[pos];
+      if (item.step) {
+        let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
+        let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
+        if (selection)
+          eventCount++;
+        rebasedItems.push(new Item(map2, step, selection));
+      } else {
+        rebasedItems.push(new Item(map2));
+      }
+    }, start);
+    let newMaps = [];
+    for (let i = rebasedCount; i < newUntil; i++)
+      newMaps.push(new Item(mapping.maps[i]));
+    let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
+    let branch = new Branch(items, eventCount);
+    if (branch.emptyItemCount() > max_empty_items)
+      branch = branch.compress(this.items.length - rebasedItems.length);
+    return branch;
+  }
+  emptyItemCount() {
+    let count = 0;
+    this.items.forEach((item) => {
+      if (!item.step)
+        count++;
+    });
+    return count;
+  }
+  compress(upto = this.items.length) {
+    let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
+    let items = [], events2 = 0;
+    this.items.forEach((item, i) => {
+      if (i >= upto) {
+        items.push(item);
+        if (item.selection)
+          events2++;
+      } else if (item.step) {
+        let step = item.step.map(remap.slice(mapFrom)), map2 = step && step.getMap();
+        mapFrom--;
+        if (map2)
+          remap.appendMap(map2, mapFrom);
+        if (step) {
+          let selection = item.selection && item.selection.map(remap.slice(mapFrom));
+          if (selection)
+            events2++;
+          let newItem = new Item(map2.invert(), step, selection), merged, last = items.length - 1;
+          if (merged = items.length && items[last].merge(newItem))
+            items[last] = merged;
+          else
+            items.push(newItem);
+        }
+      } else if (item.map) {
+        mapFrom--;
+      }
+    }, this.items.length, 0);
+    return new Branch(ropeSequence.from(items.reverse()), events2);
+  }
+}
+Branch.empty = new Branch(ropeSequence.empty, 0);
+function cutOffEvents(items, n) {
+  let cutPoint;
+  items.forEach((item, i) => {
+    if (item.selection && n-- == 0) {
+      cutPoint = i;
+      return false;
+    }
+  });
+  return items.slice(cutPoint);
+}
+class Item {
+  constructor(map2, step, selection, mirrorOffset) {
+    this.map = map2;
+    this.step = step;
+    this.selection = selection;
+    this.mirrorOffset = mirrorOffset;
+  }
+  merge(other) {
+    if (this.step && other.step && !other.selection) {
+      let step = other.step.merge(this.step);
+      if (step)
+        return new Item(step.getMap().invert(), step, this.selection);
+    }
+  }
+}
+class HistoryState {
+  constructor(done, undone, prevRanges, prevTime) {
+    this.done = done;
+    this.undone = undone;
+    this.prevRanges = prevRanges;
+    this.prevTime = prevTime;
+  }
+}
+const DEPTH_OVERFLOW = 20;
+function applyTransaction(history2, state, tr, options) {
+  let historyTr = tr.getMeta(historyKey), rebased;
+  if (historyTr)
+    return historyTr.historyState;
+  if (tr.getMeta(closeHistoryKey))
+    history2 = new HistoryState(history2.done, history2.undone, null, 0);
+  let appended = tr.getMeta("appendedTransaction");
+  if (tr.steps.length == 0) {
+    return history2;
+  } else if (appended && appended.getMeta(historyKey)) {
+    if (appended.getMeta(historyKey).redo)
+      return new HistoryState(history2.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history2.undone, rangesFor(tr.mapping.maps[tr.steps.length - 1]), history2.prevTime);
+    else
+      return new HistoryState(history2.done, history2.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history2.prevTime);
+  } else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
+    let newGroup = history2.prevTime == 0 || !appended && (history2.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history2.prevRanges));
+    let prevRanges = appended ? mapRanges(history2.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps[tr.steps.length - 1]);
+    return new HistoryState(history2.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time);
+  } else if (rebased = tr.getMeta("rebased")) {
+    return new HistoryState(history2.done.rebased(tr, rebased), history2.undone.rebased(tr, rebased), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime);
+  } else {
+    return new HistoryState(history2.done.addMaps(tr.mapping.maps), history2.undone.addMaps(tr.mapping.maps), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime);
+  }
+}
+function isAdjacentTo(transform, prevRanges) {
+  if (!prevRanges)
+    return false;
+  if (!transform.docChanged)
+    return true;
+  let adjacent = false;
+  transform.mapping.maps[0].forEach((start, end) => {
+    for (let i = 0; i < prevRanges.length; i += 2)
+      if (start <= prevRanges[i + 1] && end >= prevRanges[i])
+        adjacent = true;
+  });
+  return adjacent;
+}
+function rangesFor(map2) {
+  let result = [];
+  map2.forEach((_from, _to, from2, to) => result.push(from2, to));
+  return result;
+}
+function mapRanges(ranges, mapping) {
+  if (!ranges)
+    return null;
+  let result = [];
+  for (let i = 0; i < ranges.length; i += 2) {
+    let from2 = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
+    if (from2 <= to)
+      result.push(from2, to);
+  }
+  return result;
+}
+function histTransaction(history2, state, dispatch, redo2) {
+  let preserveItems = mustPreserveItems(state);
+  let histOptions = historyKey.get(state).spec.config;
+  let pop = (redo2 ? history2.undone : history2.done).popEvent(state, preserveItems);
+  if (!pop)
+    return;
+  let selection = pop.selection.resolve(pop.transform.doc);
+  let added = (redo2 ? history2.done : history2.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
+  let newHist = new HistoryState(redo2 ? added : pop.remaining, redo2 ? pop.remaining : added, null, 0);
+  dispatch(pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist }).scrollIntoView());
+}
+let cachedPreserveItems = false, cachedPreserveItemsPlugins = null;
+function mustPreserveItems(state) {
+  let plugins = state.plugins;
+  if (cachedPreserveItemsPlugins != plugins) {
+    cachedPreserveItems = false;
+    cachedPreserveItemsPlugins = plugins;
+    for (let i = 0; i < plugins.length; i++)
+      if (plugins[i].spec.historyPreserveItems) {
+        cachedPreserveItems = true;
+        break;
+      }
+  }
+  return cachedPreserveItems;
+}
+const historyKey = new PluginKey("history");
+const closeHistoryKey = new PluginKey("closeHistory");
+function history(config = {}) {
+  config = {
+    depth: config.depth || 100,
+    newGroupDelay: config.newGroupDelay || 500
+  };
+  return new Plugin({
+    key: historyKey,
+    state: {
+      init() {
+        return new HistoryState(Branch.empty, Branch.empty, null, 0);
+      },
+      apply(tr, hist, state) {
+        return applyTransaction(hist, state, tr, config);
+      }
+    },
+    config,
+    props: {
+      handleDOMEvents: {
+        beforeinput(view, e) {
+          let inputType = e.inputType;
+          let command2 = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
+          if (!command2)
+            return false;
+          e.preventDefault();
+          return command2(view.state, view.dispatch);
         }
-      }),
-      getFont: createCommand(({ commands: commands2 }) => {
-        const defaultPreset = unref(this.options.defaultPreset);
-        const defaultFont = commands2.findFontByName(defaultPreset.common.font_family);
-        const fontFamily = commands2.getFontFamily();
-        return computed(() => commands2.findFontByName(unref(fontFamily)) || defaultFont);
-      }),
-      findFontByName: createCommand((_, name) => {
-        return this.options.fonts.find((font) => font.name === name);
-      }),
-      getFontFamily: createCommand(({ commands: commands2 }) => {
-        return commands2.getCommonSettingMark(this.name, commands2.getDefaultFontFamily());
-      }),
-      getDefaultFontFamily: createCommand(({ commands: commands2 }) => {
-        const preset = commands2.getPreset();
-        return computed(() => unref(preset).common.font_family);
-      })
+      }
+    }
+  });
+}
+const undo = (state, dispatch) => {
+  let hist = historyKey.getState(state);
+  if (!hist || hist.done.eventCount == 0)
+    return false;
+  if (dispatch)
+    histTransaction(hist, state, dispatch, false);
+  return true;
+};
+const redo = (state, dispatch) => {
+  let hist = historyKey.getState(state);
+  if (!hist || hist.undone.eventCount == 0)
+    return false;
+  if (dispatch)
+    histTransaction(hist, state, dispatch, true);
+  return true;
+};
+const History = Extension.create({
+  name: "history",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
     };
   },
-  parseHTML() {
-    const getAttrs = (input) => ({ value: input.replace(/["']/g, "") });
-    return [
-      {
-        style: "--zw-font-family",
-        getAttrs
+  addCommands() {
+    return {
+      undo: () => ({ state, dispatch }) => {
+        return undo(state, dispatch);
       },
-      {
-        style: "font-family",
-        getAttrs
+      redo: () => ({ state, dispatch }) => {
+        return redo(state, dispatch);
       }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      history(this.options)
     ];
   },
-  renderHTML({ HTMLAttributes: attrs }) {
-    const font_family = attrs.value ? `"${attrs.value}"` : null;
-    return renderMark({ font_family });
+  addKeyboardShortcuts() {
+    return {
+      "Mod-z": () => this.editor.commands.undo(),
+      "Mod-y": () => this.editor.commands.redo(),
+      "Shift-Mod-z": () => this.editor.commands.redo(),
+      "Mod-\u044F": () => this.editor.commands.undo(),
+      "Shift-Mod-\u044F": () => this.editor.commands.redo()
+    };
   }
 });
-function makePresetClass(base2, preset) {
-  const baseClass = base2.split(" ").map((part) => `.${part}`).join("");
-  return baseClass + preset.id;
+class RemoveNodeMarkStep extends Step {
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number") {
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+    }
+    return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+  }
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
+  }
+  apply(doc2) {
+    const node = doc2.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    const updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
+    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
+    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
+  }
+  invert(doc2) {
+    const node = doc2.nodeAt(this.pos);
+    if (!node || !this.mark.isInSet(node.marks))
+      return this;
+    return new AddNodeMarkStep(this.pos, this.mark);
+  }
+  map(mapping) {
+    const pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
 }
-const StylePreset = Extension.create({
-  name: TextSettings.STYLE_PRESET,
-  addStorage: () => ({
-    presetStyleEl: null
-  }),
-  addGlobalAttributes() {
-    return [
-      {
-        types: [NodeTypes.PARAGRAPH, NodeTypes.HEADING],
-        attributes: {
-          preset: {
-            isRequired: false,
-            default: { id: this.options.defaultId },
-            parseHTML: (element) => {
-              const presets = unref(this.options.presets);
-              if (element.parentElement.tagName === "LI")
-                return null;
-              for (const { id: id2, node, fallbackClass } of presets) {
-                const isFallback = fallbackClass && element.classList.contains(fallbackClass);
-                if (isFallback)
-                  return { id: id2 };
-                const className = makePresetClass(this.options.baseClass, { id: id2 });
-                if (element.matches(className))
-                  return { id: id2 };
-                if (element.tagName === `H${node == null ? void 0 : node.level}`)
-                  return { id: id2 };
-              }
-              return element.tagName === "P" ? { id: this.options.defaultId } : null;
-            },
-            renderHTML: (attrs) => {
-              if (!attrs.preset)
-                return null;
-              return { class: this.options.baseClass + attrs.preset.id };
-            }
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+class AddNodeMarkStep extends Step {
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number") {
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+    }
+    return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+  }
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
+  }
+  apply(doc2) {
+    const node = doc2.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    const updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
+    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
+    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
+  }
+  invert(doc2) {
+    const node = doc2.nodeAt(this.pos);
+    if (node) {
+      const newSet = this.mark.addToSet(node.marks);
+      if (newSet.length === node.marks.length) {
+        for (const mark of node.marks) {
+          if (!mark.isInSet(newSet)) {
+            return new AddNodeMarkStep(this.pos, mark);
           }
         }
+        return new AddNodeMarkStep(this.pos, this.mark);
       }
-    ];
-  },
-  addCommands() {
-    function findPresetById(presets, id2) {
-      return presets.find((preset) => id2 === preset.id);
     }
-    function mergeSettings(source, target) {
-      const settings = {};
-      for (const name of Object.keys(source)) {
-        const sourceValue = source[name];
-        const targetValue = target[name];
-        const isInherit = !targetValue || targetValue.toLowerCase() === "inherit";
-        settings[name] = isInherit ? sourceValue : targetValue;
-      }
-      return settings;
+    return new RemoveNodeMarkStep(this.pos, this.mark);
+  }
+  map(mapping) {
+    const pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+}
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+class AttrStep extends Step {
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number" || typeof json.attr != "string") {
+      throw new RangeError("Invalid input for AttrStep.fromJSON");
     }
+    return new AttrStep(json.pos, json.attr, json.value);
+  }
+  constructor(pos, attr, value) {
+    super();
+    this.pos = pos;
+    this.attr = attr;
+    this.value = value;
+  }
+  apply(doc2) {
+    const node = doc2.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at attribute step's position");
+    const attrs = /* @__PURE__ */ Object.create(null);
+    for (let name in node.attrs)
+      attrs[name] = node.attrs[name];
+    attrs[this.attr] = this.value;
+    const updated = node.type.create(attrs, null, node.marks);
+    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
+    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
+  }
+  getMap() {
+    return StepMap.empty;
+  }
+  invert(doc2) {
+    return new AttrStep(this.pos, this.attr, doc2.nodeAt(this.pos).attrs[this.attr]);
+  }
+  map(mapping) {
+    let pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
+  }
+  toJSON() {
+    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+  }
+}
+Step.jsonID("attr", AttrStep);
+const NodeProcessor = Extension.create({
+  name: "node_processor",
+  addCommands() {
     return {
-      getPresetList: createCommand(() => computed(() => {
-        return this.options.presets.filter((preset) => !preset.hidden);
-      })),
-      getPreset: createCommand(({ commands: commands2 }) => {
-        const selectionRef = commands2.getBlockAttributes("preset", { id: this.options.defaultId });
-        const presetsRef = commands2.getPresetList();
-        const isLinkRef = commands2.isLink();
-        const linkPresetRef = commands2.getLinkPreset();
-        return computed(() => {
-          const preset = findPresetById(unref(presetsRef), unref(selectionRef).id);
-          if (!unref(isLinkRef))
-            return preset;
-          const linkPreset = unref(linkPresetRef);
-          return {
-            id: preset.id,
-            common: mergeSettings(preset.common, linkPreset.common),
-            mobile: mergeSettings(preset.mobile, linkPreset.mobile),
-            tablet: mergeSettings(preset.tablet, linkPreset.tablet),
-            desktop: mergeSettings(preset.desktop, linkPreset.desktop)
-          };
+      setBlockAttributes: createCommand(({ commands: commands2, state }, name, attrs, defaults2 = {}) => {
+        var _a;
+        const current = (_a = unref(commands2.getBlockAttributes(name))) != null ? _a : {};
+        const { doc: doc2, tr } = state;
+        const { from: from2, to } = tr.selection;
+        doc2.nodesBetween(from2, to, (node, position) => {
+          if (!NodeTypes.blocks.includes(node.type.name))
+            return;
+          tr.step(new AttrStep(position, name, { ...defaults2, ...current, ...attrs }));
         });
       }),
-      applyPreset: createCommand(({ commands: commands2, chain }, presetId) => {
-        var _a, _b;
-        const presets = unref(commands2.getPresetList());
-        const preset = findPresetById(presets, presetId);
-        const nodeType = (_b = (_a = preset.node) == null ? void 0 : _a.type) != null ? _b : NodeTypes.PARAGRAPH;
-        const attrs = {
-          preset: { id: presetId }
-        };
-        if (preset.node) {
-          attrs.level = preset.node.level;
+      getBlockAttributes: createCommand(({ editor }, name, defaults2) => computed(() => {
+        var _a;
+        let attrs = Object.assign({}, defaults2 || {});
+        for (const type of NodeTypes.blocks) {
+          Object.assign(attrs, ((_a = editor.getAttributes(type)) == null ? void 0 : _a[name]) || {});
         }
-        for (const textAttribute of TextSettings.attributes) {
-          attrs[textAttribute] = unref(commands2.getBlockAttributes(textAttribute));
+        return Object.keys(attrs).length ? attrs : null;
+      })),
+      removeBlockAttributes: createCommand(({ commands: commands2 }, names) => {
+        for (const type of NodeTypes.blocks) {
+          commands2.resetAttributes(type, names);
         }
-        chain().removeList().setNode(nodeType, attrs).run();
       }),
-      applyDefaultPreset: createCommand(({ commands: commands2 }) => {
-        commands2.applyPreset(this.options.defaultId);
+      applyMark: createCommand(({ state, commands: commands2 }, name, value, customizer = {}) => {
+        const { tr, doc: doc2, schema } = state;
+        const { $from, $to } = tr.selection;
+        const linkMarkType = getMarkType(TextSettings.LINK, schema);
+        const markType = getMarkType(name, schema);
+        const markGroup = markType.spec.group || "";
+        if (!markGroup.includes(MarkGroups.SETTINGS)) {
+          return commands2.setMark(name, value);
+        }
+        if ($from.pos === $to.pos)
+          return;
+        const onAppliedToParent = (context) => {
+          if (!customizer.onAppliedToParent || customizer.onAppliedToParent(context) === false) {
+            const { tr: tr2, node, position, mark } = context;
+            commands2._removeNodeMark({ tr: tr2, node, position, mark: mark.type });
+          }
+        };
+        doc2.nodesBetween($from.pos, $to.pos, (node, position) => {
+          if (node.type.name === NodeTypes.LIST)
+            return;
+          const initialMark = findMarkByType(node.marks, name);
+          const applyingMark = markType.create({ ...(initialMark == null ? void 0 : initialMark.attrs) || {}, ...value });
+          const textPosition = resolveTextPosition($from, $to, node, position);
+          const isAppliedToParent = !linkMarkType.isInSet(node.marks) && isMarkAppliedToParent(tr.doc, position, applyingMark, customizer.isAppliedToParent);
+          if (isAppliedToParent) {
+            return onAppliedToParent({ tr, node, position, mark: applyingMark });
+          }
+          if (node.isText) {
+            tr.addMark(textPosition.from, textPosition.to, applyingMark);
+            return;
+          }
+          if (isNodeFullySelected(tr.doc, tr.selection, node, position)) {
+            tr.step(new AddNodeMarkStep(position, applyingMark));
+          }
+        });
       }),
-      removePreset: createCommand(({ commands: commands2 }) => {
-        commands2.setNode(NodeTypes.PARAGRAPH, { preset: null });
+      getMarks: createCommand(({ editor }, name) => {
+        const stateRef = toRef(editor, "state");
+        return computed(() => {
+          const { selection, doc: doc2 } = unref(stateRef);
+          const { from: from2, to } = unref(selection);
+          const marks = [];
+          doc2.nodesBetween(from2, to, (node) => {
+            for (const mark of node.marks) {
+              if (mark.type.name === name)
+                marks.unshift(mark.attrs);
+            }
+          });
+          return marks;
+        });
       }),
-      getPresetCustomization: createCommand(({ editor, commands: commands2 }) => {
-        const state = toRef(editor, "state");
+      getMark: createCommand(({ commands: commands2 }, name) => {
+        const marksRef = commands2.getMarks(name);
         return computed(() => {
-          const { selection, doc: doc2 } = unref(state);
-          const { from: from2, to } = selection;
-          return commands2._getSettingCustomization(doc2, from2, to);
+          var _a;
+          return (_a = unref(marksRef)[0]) != null ? _a : null;
         });
       }),
-      isSettingCustomized: createCommand(({ commands: commands2 }, name) => {
-        const customization = commands2.getPresetCustomization();
-        const group = TextSettings.attributes.includes(name) ? "attributes" : "marks";
+      hasMark: createCommand(({ commands: commands2 }, name) => {
+        const mark = commands2.getMark(name);
+        return computed(() => !!unref(mark));
+      }),
+      getCommonSettingMark: createCommand(({ commands: commands2 }, name, defaultRef) => {
+        const selectionRef = commands2.getMark(name);
         return computed(() => {
           var _a, _b;
-          return (_b = (_a = unref(customization)[group]) == null ? void 0 : _a.includes(name)) != null ? _b : false;
+          return (_b = (_a = unref(selectionRef)) == null ? void 0 : _a.value) != null ? _b : unref(defaultRef);
         });
       }),
-      getContentCustomization: createCommand(({ editor, commands: commands2 }) => {
-        const state = toRef(editor, "state");
+      getDeviceSettingMark: createCommand(({ commands: commands2 }, name, defaultRef) => {
+        const selectionRef = commands2.getMarks(name);
+        const deviceRef = commands2.getDevice();
         return computed(() => {
-          const { doc: doc2 } = unref(state);
-          return commands2._getSettingCustomization(doc2, 0, doc2.content.size);
+          for (const attrs of unref(selectionRef)) {
+            const value = attrs[unref(deviceRef)];
+            if (value)
+              return value;
+          }
+          return unref(defaultRef);
         });
       }),
-      _getSettingCustomization: createCommand((_, doc2, from2, to) => {
-        const marks = /* @__PURE__ */ new Set();
-        const attributes = /* @__PURE__ */ new Set();
-        doc2.nodesBetween(from2, to, (node) => {
-          for (const [name, value] of Object.entries(node.attrs)) {
-            const isSetting = TextSettings.attributes.includes(name);
-            if (isSetting && value)
-              attributes.add(name);
+      removeAllMarks: createCommand(({ state, commands: commands2 }) => {
+        const { tr, doc: doc2 } = state;
+        const { from: from2, to } = tr.selection;
+        doc2.nodesBetween(from2, to, (node, position) => {
+          for (const mark of node.marks) {
+            commands2._removeNodeMark({ tr, node, position, mark });
           }
-          for (const { type } of node.marks) {
-            if (TextSettings.marks.includes(type.name)) {
-              marks.add(type.name);
-            }
+        });
+      }),
+      removeMarks: createCommand(({ state, commands: commands2 }, marks) => {
+        const { tr, doc: doc2 } = state;
+        const { from: from2, to } = tr.selection;
+        doc2.nodesBetween(from2, to, (node, position) => {
+          const removingMarks = node.marks.filter((mark) => marks.includes(mark.type.name));
+          for (const mark of removingMarks) {
+            commands2._removeNodeMark({ tr, node, position, mark });
           }
         });
-        return {
-          attributes: Array.from(attributes),
-          marks: Array.from(marks)
-        };
       }),
-      removePresetCustomization: createCommand(({ chain }) => {
-        chain().storeSelection().expandSelectionToBlock().removeMarks(TextSettings.marks).resetAttributes(NodeTypes.PARAGRAPH, TextSettings.attributes).resetAttributes(NodeTypes.HEADING, TextSettings.attributes).restoreSelection().run();
+      _removeNodeMark: createCommand((context, { tr, node, position, mark }) => {
+        return node.isText ? tr.removeMark(position, position + node.nodeSize, mark) : tr.step(new RemoveNodeMarkStep(position, mark));
+      })
+    };
+  }
+});
+const TextProcessor = Extension.create({
+  name: "text_processor",
+  addCommands() {
+    return {
+      getSelectedText: createCommand(({ state }) => {
+        const { from: from2, to } = state.selection;
+        return state.doc.textBetween(from2, to, " ");
       }),
-      removeFormat: createCommand(({ chain }) => {
-        chain().storeSelection().expandSelectionToBlock().removeAllMarks().applyDefaultPreset().restoreSelection().run();
+      transformText: createCommand(({ state }, transform) => {
+        const { $from, $to } = state.tr.selection;
+        if ($from.pos === $to.pos)
+          return;
+        state.doc.nodesBetween($from.pos, $to.pos, (node, position) => {
+          if (!node.isText)
+            return;
+          const textPosition = resolveTextPosition($from, $to, node, position);
+          const substringFrom = Math.max(0, $from.pos - position);
+          const substringTo = Math.max(0, $to.pos - position);
+          const updatedText = transform({
+            text: node.textContent.substring(substringFrom, substringTo)
+          });
+          const updatedNode = state.schema.text(updatedText, node.marks);
+          state.tr.replaceWith(textPosition.from, textPosition.to, updatedNode);
+        });
       })
     };
-  },
-  onCreate() {
-    const existingStyleEl = ContextWindow.document.querySelector("[data-zw-styles]");
-    if (existingStyleEl) {
-      this.storage.presetStyleEl = existingStyleEl;
-      return;
-    }
-    this.storage.presetStyleEl = ContextWindow.document.createElement("style");
-    this.storage.presetStyleEl.dataset.zwStyles = "";
-    for (const preset of this.options.presets) {
-      const className = makePresetClass(this.options.baseClass, preset);
-      const css = [` ${className} {`];
-      for (const device of Devices.values) {
-        for (const setting of Object.keys(preset[device])) {
-          const variable = this.options.makeVariable({ device, preset, property: setting });
-          const property = setting.replace(/_/i, "-");
-          const prefix = device === Devices.COMMON ? "preset" : `preset-${device}`;
-          css.push(`--zw-${prefix}-${property}: var(${variable}, inherit);`);
-        }
-      }
-      css.push("}");
-      this.storage.presetStyleEl.innerHTML += css.join(" ");
-    }
-    ContextWindow.head.append(this.storage.presetStyleEl);
   }
 });
-const FontWeight = Mark.create({
-  name: TextSettings.FONT_WEIGHT,
-  group: MarkGroups.SETTINGS,
-  addAttributes: () => ({
-    value: { required: true }
+const SelectionProcessor = Extension.create({
+  name: "selection_processor",
+  addStorage: () => ({
+    selection: null
   }),
   addCommands() {
     return {
-      applyFontWeight: createCommand(({ commands: commands2 }, value) => {
-        commands2.applyMark(this.name, { value });
-        const font = unref(commands2.getFont());
-        if (!font.isItalicSupported(value)) {
-          commands2.removeItalic();
-        }
+      storeSelection: createCommand(({ state }) => {
+        this.storage.selection = state.selection;
       }),
-      toggleBold: createCommand(({ commands: commands2 }) => {
-        const currentWeight = unref(commands2.getFontWeight());
-        const currentFont = unref(commands2.getFont());
-        const isBold = Number(currentWeight) >= 600;
-        const wantedWeight = isBold ? "400" : "700";
-        const nextWeight = currentFont.findClosestWeight(wantedWeight);
-        commands2.applyFontWeight(nextWeight);
+      restoreSelection: createCommand(({ commands: commands2 }) => {
+        this.storage.selection && commands2.setTextSelection(this.storage.selection);
       }),
-      getFontWeight: createCommand(({ commands: commands2 }) => {
-        const selectionRef = commands2.getCommonSettingMark(this.name, commands2.getDefaultFontWeight());
-        const fontRef = commands2.getFont();
-        return computed(() => {
-          const weight = unref(selectionRef);
-          const font = unref(fontRef);
-          return font.isWeightSupported(weight) ? weight : font.findClosestWeight(weight);
+      expandSelection: createCommand(({ tr, commands: commands2 }, predicate) => {
+        let from2 = tr.selection.from;
+        let to = tr.selection.to;
+        tr.doc.nodesBetween(from2, to, (node, position, parent) => {
+          if (predicate({ node, parent })) {
+            const offset2 = node.isText ? 0 : resolvePositionOffset(tr.doc, position);
+            from2 = Math.min(from2, position + offset2);
+            to = Math.max(to, position + node.nodeSize - offset2);
+          }
         });
+        commands2.setTextSelection({ from: from2, to });
       }),
-      getDefaultFontWeight: createCommand(({ commands: commands2 }) => {
-        const preset = commands2.getPreset();
-        return computed(() => unref(preset).common.font_weight);
+      expandSelectionToBlock: createCommand(({ commands: commands2 }) => {
+        commands2.expandSelection(({ parent }) => parent.type.name === NodeTypes.DOCUMENT);
       })
     };
-  },
-  addKeyboardShortcuts: () => ({
-    "Mod-b": createKeyboardShortcut("toggleBold"),
-    "Mod-B": createKeyboardShortcut("toggleBold")
-  }),
-  parseHTML() {
-    const getAttrs = (value) => {
-      if (value === "bold")
-        return { value: "700" };
-      return Number(value) ? { value } : false;
-    };
-    return [
-      {
-        style: "--zw-font-weight",
-        getAttrs
-      },
-      {
-        style: "font-weight",
-        getAttrs
-      },
-      {
-        tag: "b",
-        attrs: { value: "700" }
-      },
-      {
-        tag: "strong",
-        attrs: { value: "700" }
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: attrs }) {
-    return renderMark({ font_weight: attrs.value });
   }
 });
-const Text$1 = Node.create({
-  name: "text",
-  group: "inline"
+const Document$1 = Node.create({
+  name: "doc",
+  topNode: true,
+  content: "block+"
 });
-var GOOD_LEAF_SIZE = 200;
-var RopeSequence = function RopeSequence2() {
-};
-RopeSequence.prototype.append = function append(other) {
-  if (!other.length) {
-    return this;
-  }
-  other = RopeSequence.from(other);
-  return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
-};
-RopeSequence.prototype.prepend = function prepend(other) {
-  if (!other.length) {
-    return this;
-  }
-  return RopeSequence.from(other).append(this);
-};
-RopeSequence.prototype.appendInner = function appendInner(other) {
-  return new Append(this, other);
-};
-RopeSequence.prototype.slice = function slice(from2, to) {
-  if (from2 === void 0)
-    from2 = 0;
-  if (to === void 0)
-    to = this.length;
-  if (from2 >= to) {
-    return RopeSequence.empty;
-  }
-  return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
-};
-RopeSequence.prototype.get = function get(i) {
-  if (i < 0 || i >= this.length) {
-    return void 0;
-  }
-  return this.getInner(i);
-};
-RopeSequence.prototype.forEach = function forEach(f, from2, to) {
-  if (from2 === void 0)
-    from2 = 0;
-  if (to === void 0)
-    to = this.length;
-  if (from2 <= to) {
-    this.forEachInner(f, from2, to, 0);
-  } else {
-    this.forEachInvertedInner(f, from2, to, 0);
-  }
-};
-RopeSequence.prototype.map = function map(f, from2, to) {
-  if (from2 === void 0)
-    from2 = 0;
-  if (to === void 0)
-    to = this.length;
-  var result = [];
-  this.forEach(function(elt, i) {
-    return result.push(f(elt, i));
-  }, from2, to);
-  return result;
-};
-RopeSequence.from = function from(values2) {
-  if (values2 instanceof RopeSequence) {
-    return values2;
-  }
-  return values2 && values2.length ? new Leaf(values2) : RopeSequence.empty;
-};
-var Leaf = /* @__PURE__ */ function(RopeSequence3) {
-  function Leaf2(values2) {
-    RopeSequence3.call(this);
-    this.values = values2;
-  }
-  if (RopeSequence3)
-    Leaf2.__proto__ = RopeSequence3;
-  Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
-  Leaf2.prototype.constructor = Leaf2;
-  var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
-  Leaf2.prototype.flatten = function flatten() {
-    return this.values;
-  };
-  Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
-    if (from2 == 0 && to == this.length) {
-      return this;
-    }
-    return new Leaf2(this.values.slice(from2, to));
-  };
-  Leaf2.prototype.getInner = function getInner(i) {
-    return this.values[i];
-  };
-  Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
-    for (var i = from2; i < to; i++) {
-      if (f(this.values[i], start + i) === false) {
-        return false;
-      }
-    }
-  };
-  Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
-    for (var i = from2 - 1; i >= to; i--) {
-      if (f(this.values[i], start + i) === false) {
-        return false;
-      }
-    }
-  };
-  Leaf2.prototype.leafAppend = function leafAppend(other) {
-    if (this.length + other.length <= GOOD_LEAF_SIZE) {
-      return new Leaf2(this.values.concat(other.flatten()));
-    }
-  };
-  Leaf2.prototype.leafPrepend = function leafPrepend(other) {
-    if (this.length + other.length <= GOOD_LEAF_SIZE) {
-      return new Leaf2(other.flatten().concat(this.values));
-    }
-  };
-  prototypeAccessors.length.get = function() {
-    return this.values.length;
-  };
-  prototypeAccessors.depth.get = function() {
-    return 0;
-  };
-  Object.defineProperties(Leaf2.prototype, prototypeAccessors);
-  return Leaf2;
-}(RopeSequence);
-RopeSequence.empty = new Leaf([]);
-var Append = /* @__PURE__ */ function(RopeSequence3) {
-  function Append2(left, right) {
-    RopeSequence3.call(this);
-    this.left = left;
-    this.right = right;
-    this.length = left.length + right.length;
-    this.depth = Math.max(left.depth, right.depth) + 1;
-  }
-  if (RopeSequence3)
-    Append2.__proto__ = RopeSequence3;
-  Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
-  Append2.prototype.constructor = Append2;
-  Append2.prototype.flatten = function flatten() {
-    return this.left.flatten().concat(this.right.flatten());
-  };
-  Append2.prototype.getInner = function getInner(i) {
-    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
-  };
-  Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
-    var leftLen = this.left.length;
-    if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
-      return false;
-    }
-    if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
-      return false;
-    }
-  };
-  Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
-    var leftLen = this.left.length;
-    if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
-      return false;
-    }
-    if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
-      return false;
-    }
-  };
-  Append2.prototype.sliceInner = function sliceInner(from2, to) {
-    if (from2 == 0 && to == this.length) {
-      return this;
-    }
-    var leftLen = this.left.length;
-    if (to <= leftLen) {
-      return this.left.slice(from2, to);
-    }
-    if (from2 >= leftLen) {
-      return this.right.slice(from2 - leftLen, to - leftLen);
-    }
-    return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
-  };
-  Append2.prototype.leafAppend = function leafAppend(other) {
-    var inner = this.right.leafAppend(other);
-    if (inner) {
-      return new Append2(this.left, inner);
-    }
-  };
-  Append2.prototype.leafPrepend = function leafPrepend(other) {
-    var inner = this.left.leafPrepend(other);
-    if (inner) {
-      return new Append2(inner, this.right);
-    }
-  };
-  Append2.prototype.appendInner = function appendInner2(other) {
-    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
-      return new Append2(this.left, new Append2(this.right, other));
-    }
-    return new Append2(this, other);
-  };
-  return Append2;
-}(RopeSequence);
-var ropeSequence = RopeSequence;
-const max_empty_items = 500;
-class Branch {
-  constructor(items, eventCount) {
-    this.items = items;
-    this.eventCount = eventCount;
+const Document = Document$1.extend({
+  marks: MarkGroups.SETTINGS
+});
+const Paragraph$1 = Node.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [
+      { tag: "p" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["p", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands: commands2 }) => {
+        return commands2.setNode(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
   }
-  popEvent(state, preserveItems) {
-    if (this.eventCount == 0)
-      return null;
-    let end = this.items.length;
-    for (; ; end--) {
-      let next2 = this.items.get(end - 1);
-      if (next2.selection) {
-        --end;
-        break;
+});
+const Paragraph = Paragraph$1.extend({
+  marks: MarkGroups.ALL,
+  addOptions: () => ({
+    HTMLAttributes: { class: "zw-style" }
+  })
+});
+const Heading$1 = Node.create({
+  name: "heading",
+  addOptions() {
+    return {
+      levels: [1, 2, 3, 4, 5, 6],
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  group: "block",
+  defining: true,
+  addAttributes() {
+    return {
+      level: {
+        default: 1,
+        rendered: false
       }
-    }
-    let remap, mapFrom;
-    if (preserveItems) {
-      remap = this.remapping(end, this.items.length);
-      mapFrom = remap.maps.length;
-    }
-    let transform = state.tr;
-    let selection, remaining;
-    let addAfter = [], addBefore = [];
-    this.items.forEach((item, i) => {
-      if (!item.step) {
-        if (!remap) {
-          remap = this.remapping(end, i + 1);
-          mapFrom = remap.maps.length;
+    };
+  },
+  parseHTML() {
+    return this.options.levels.map((level) => ({
+      tag: `h${level}`,
+      attrs: { level }
+    }));
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const hasLevel = this.options.levels.includes(node.attrs.level);
+    const level = hasLevel ? node.attrs.level : this.options.levels[0];
+    return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setHeading: (attributes) => ({ commands: commands2 }) => {
+        if (!this.options.levels.includes(attributes.level)) {
+          return false;
         }
-        mapFrom--;
-        addBefore.push(item);
-        return;
-      }
-      if (remap) {
-        addBefore.push(new Item(item.map));
-        let step = item.step.map(remap.slice(mapFrom)), map2;
-        if (step && transform.maybeStep(step).doc) {
-          map2 = transform.mapping.maps[transform.mapping.maps.length - 1];
-          addAfter.push(new Item(map2, void 0, void 0, addAfter.length + addBefore.length));
+        return commands2.setNode(this.name, attributes);
+      },
+      toggleHeading: (attributes) => ({ commands: commands2 }) => {
+        if (!this.options.levels.includes(attributes.level)) {
+          return false;
         }
-        mapFrom--;
-        if (map2)
-          remap.appendMap(map2, mapFrom);
-      } else {
-        transform.maybeStep(item.step);
-      }
-      if (item.selection) {
-        selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
-        remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
-        return false;
-      }
-    }, this.items.length, 0);
-    return { remaining, transform, selection };
-  }
-  addTransform(transform, selection, histOptions, preserveItems) {
-    let newItems = [], eventCount = this.eventCount;
-    let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
-    for (let i = 0; i < transform.steps.length; i++) {
-      let step = transform.steps[i].invert(transform.docs[i]);
-      let item = new Item(transform.mapping.maps[i], step, selection), merged;
-      if (merged = lastItem && lastItem.merge(item)) {
-        item = merged;
-        if (i)
-          newItems.pop();
-        else
-          oldItems = oldItems.slice(0, oldItems.length - 1);
-      }
-      newItems.push(item);
-      if (selection) {
-        eventCount++;
-        selection = void 0;
+        return commands2.toggleNode(this.name, "paragraph", attributes);
       }
-      if (!preserveItems)
-        lastItem = item;
-    }
-    let overflow = eventCount - histOptions.depth;
-    if (overflow > DEPTH_OVERFLOW) {
-      oldItems = cutOffEvents(oldItems, overflow);
-      eventCount -= overflow;
-    }
-    return new Branch(oldItems.append(newItems), eventCount);
-  }
-  remapping(from2, to) {
-    let maps = new Mapping();
-    this.items.forEach((item, i) => {
-      let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from2 ? maps.maps.length - item.mirrorOffset : void 0;
-      maps.appendMap(item.map, mirrorPos);
-    }, from2, to);
-    return maps;
-  }
-  addMaps(array) {
-    if (this.eventCount == 0)
-      return this;
-    return new Branch(this.items.append(array.map((map2) => new Item(map2))), this.eventCount);
-  }
-  rebased(rebasedTransform, rebasedCount) {
-    if (!this.eventCount)
-      return this;
-    let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
-    let mapping = rebasedTransform.mapping;
-    let newUntil = rebasedTransform.steps.length;
-    let eventCount = this.eventCount;
-    this.items.forEach((item) => {
-      if (item.selection)
-        eventCount--;
-    }, start);
-    let iRebased = rebasedCount;
-    this.items.forEach((item) => {
-      let pos = mapping.getMirror(--iRebased);
-      if (pos == null)
-        return;
-      newUntil = Math.min(newUntil, pos);
-      let map2 = mapping.maps[pos];
-      if (item.step) {
-        let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
-        let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
-        if (selection)
-          eventCount++;
-        rebasedItems.push(new Item(map2, step, selection));
-      } else {
-        rebasedItems.push(new Item(map2));
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce((items, level) => ({
+      ...items,
+      ...{
+        [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
       }
-    }, start);
-    let newMaps = [];
-    for (let i = rebasedCount; i < newUntil; i++)
-      newMaps.push(new Item(mapping.maps[i]));
-    let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
-    let branch = new Branch(items, eventCount);
-    if (branch.emptyItemCount() > max_empty_items)
-      branch = branch.compress(this.items.length - rebasedItems.length);
-    return branch;
+    }), {});
+  },
+  addInputRules() {
+    return this.options.levels.map((level) => {
+      return textblockTypeInputRule({
+        find: new RegExp(`^(#{1,${level}})\\s$`),
+        type: this.type,
+        getAttributes: {
+          level
+        }
+      });
+    });
   }
-  emptyItemCount() {
-    let count = 0;
-    this.items.forEach((item) => {
-      if (!item.step)
-        count++;
+});
+const Heading = Heading$1.extend({
+  marks: MarkGroups.ALL,
+  addOptions: () => ({
+    levels: [1, 2, 3, 4],
+    HTMLAttributes: { class: "zw-style" }
+  })
+});
+class ProseMirrorPlugin {
+  static create(editor, options) {
+    const plugin = new this(editor, options || {});
+    return new Plugin({
+      key: new PluginKey(this.name),
+      props: plugin.buildProps()
     });
-    return count;
   }
-  compress(upto = this.items.length) {
-    let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
-    let items = [], events2 = 0;
-    this.items.forEach((item, i) => {
-      if (i >= upto) {
-        items.push(item);
-        if (item.selection)
-          events2++;
-      } else if (item.step) {
-        let step = item.step.map(remap.slice(mapFrom)), map2 = step && step.getMap();
-        mapFrom--;
-        if (map2)
-          remap.appendMap(map2, mapFrom);
-        if (step) {
-          let selection = item.selection && item.selection.map(remap.slice(mapFrom));
-          if (selection)
-            events2++;
-          let newItem = new Item(map2.invert(), step, selection), merged, last = items.length - 1;
-          if (merged = items.length && items[last].merge(newItem))
-            items[last] = merged;
-          else
-            items.push(newItem);
-        }
-      } else if (item.map) {
-        mapFrom--;
-      }
-    }, this.items.length, 0);
-    return new Branch(ropeSequence.from(items.reverse()), events2);
+  constructor(editor, options) {
+    this.options = options;
+    this.editor = editor;
+  }
+  buildProps() {
+    return {};
   }
 }
-Branch.empty = new Branch(ropeSequence.empty, 0);
-function cutOffEvents(items, n) {
-  let cutPoint;
-  items.forEach((item, i) => {
-    if (item.selection && n-- == 0) {
-      cutPoint = i;
-      return false;
+class PastePlugin extends ProseMirrorPlugin {
+  buildProps() {
+    return {
+      transformPastedHTML: this._transformPastedHTML.bind(this),
+      handlePaste: this._handlePaste.bind(this)
+    };
+  }
+  _transformPastedHTML(html2) {
+    if (html2.includes("data-pm-slice") && html2.includes("zw-style")) {
+      return html2;
     }
-  });
-  return items.slice(cutPoint);
-}
-class Item {
-  constructor(map2, step, selection, mirrorOffset) {
-    this.map = map2;
-    this.step = step;
-    this.selection = selection;
-    this.mirrorOffset = mirrorOffset;
+    const normalizer = ContentNormalizer.build(html2);
+    normalizer.normalizeHTML();
+    this._removeDeprecatedStyles(normalizer);
+    return normalizer.normalizedHTML;
   }
-  merge(other) {
-    if (this.step && other.step && !other.selection) {
-      let step = other.step.merge(this.step);
-      if (step)
-        return new Item(step.getMap().invert(), step, this.selection);
+  _removeDeprecatedStyles(normalizer) {
+    const elements = normalizer.dom.querySelectorAll('[style*="margin"]');
+    for (const element of Array.from(elements)) {
+      element.style.removeProperty("margin");
+      element.style.removeProperty("margin-top");
+      element.style.removeProperty("margin-right");
+      element.style.removeProperty("margin-bottom");
+      element.style.removeProperty("margin-left");
     }
   }
-}
-class HistoryState {
-  constructor(done, undone, prevRanges, prevTime) {
-    this.done = done;
-    this.undone = undone;
-    this.prevRanges = prevRanges;
-    this.prevTime = prevTime;
+  _handlePaste(view, _, slice2) {
+    const transaction = this._insertPastedContent(view, slice2).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste");
+    view.dispatch(transaction);
+    return true;
   }
-}
-const DEPTH_OVERFLOW = 20;
-function applyTransaction(history2, state, tr, options) {
-  let historyTr = tr.getMeta(historyKey), rebased;
-  if (historyTr)
-    return historyTr.historyState;
-  if (tr.getMeta(closeHistoryKey))
-    history2 = new HistoryState(history2.done, history2.undone, null, 0);
-  let appended = tr.getMeta("appendedTransaction");
-  if (tr.steps.length == 0) {
-    return history2;
-  } else if (appended && appended.getMeta(historyKey)) {
-    if (appended.getMeta(historyKey).redo)
-      return new HistoryState(history2.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history2.undone, rangesFor(tr.mapping.maps[tr.steps.length - 1]), history2.prevTime);
-    else
-      return new HistoryState(history2.done, history2.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history2.prevTime);
-  } else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
-    let newGroup = history2.prevTime == 0 || !appended && (history2.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history2.prevRanges));
-    let prevRanges = appended ? mapRanges(history2.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps[tr.steps.length - 1]);
-    return new HistoryState(history2.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time);
-  } else if (rebased = tr.getMeta("rebased")) {
-    return new HistoryState(history2.done.rebased(tr, rebased), history2.undone.rebased(tr, rebased), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime);
-  } else {
-    return new HistoryState(history2.done.addMaps(tr.mapping.maps), history2.undone.addMaps(tr.mapping.maps), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime);
+  _insertPastedContent({ state, input }, slice2) {
+    if (!this._isFullBlockSelected(state)) {
+      return state.tr.replaceSelection(slice2);
+    }
+    return state.tr.replaceSelectionWith(slice2.content, input.shiftKey);
   }
-}
-function isAdjacentTo(transform, prevRanges) {
-  if (!prevRanges)
-    return false;
-  if (!transform.docChanged)
-    return true;
-  let adjacent = false;
-  transform.mapping.maps[0].forEach((start, end) => {
-    for (let i = 0; i < prevRanges.length; i += 2)
-      if (start <= prevRanges[i + 1] && end >= prevRanges[i])
-        adjacent = true;
-  });
-  return adjacent;
-}
-function rangesFor(map2) {
-  let result = [];
-  map2.forEach((_from, _to, from2, to) => result.push(from2, to));
-  return result;
-}
-function mapRanges(ranges, mapping) {
-  if (!ranges)
-    return null;
-  let result = [];
-  for (let i = 0; i < ranges.length; i += 2) {
-    let from2 = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
-    if (from2 <= to)
-      result.push(from2, to);
+  _isFullBlockSelected(state) {
+    const blocksSelection = this._expandSelectionToBlocks(state);
+    const isFromMatch = this._isMatchPosition(blocksSelection.from, state.selection.from);
+    const isToMatch = this._isMatchPosition(blocksSelection.to, state.selection.to);
+    return isFromMatch && isToMatch;
+  }
+  _expandSelectionToBlocks({ selection, doc: doc2 }) {
+    let from2 = selection.from;
+    let to = selection.to;
+    doc2.nodesBetween(from2, to, (node, position, parent) => {
+      if (parent.type.name !== NodeTypes.DOCUMENT)
+        return;
+      from2 = Math.min(from2, position + 1);
+      to = Math.max(to, position + node.nodeSize - 1);
+    });
+    return { from: from2, to };
+  }
+  _isMatchPosition(position1, position2) {
+    return Math.abs(position1 - position2) < 5;
   }
-  return result;
-}
-function histTransaction(history2, state, dispatch, redo2) {
-  let preserveItems = mustPreserveItems(state);
-  let histOptions = historyKey.get(state).spec.config;
-  let pop = (redo2 ? history2.undone : history2.done).popEvent(state, preserveItems);
-  if (!pop)
-    return;
-  let selection = pop.selection.resolve(pop.transform.doc);
-  let added = (redo2 ? history2.done : history2.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
-  let newHist = new HistoryState(redo2 ? added : pop.remaining, redo2 ? pop.remaining : added, null, 0);
-  dispatch(pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist }).scrollIntoView());
 }
-let cachedPreserveItems = false, cachedPreserveItemsPlugins = null;
-function mustPreserveItems(state) {
-  let plugins = state.plugins;
-  if (cachedPreserveItemsPlugins != plugins) {
-    cachedPreserveItems = false;
-    cachedPreserveItemsPlugins = plugins;
-    for (let i = 0; i < plugins.length; i++)
-      if (plugins[i].spec.historyPreserveItems) {
-        cachedPreserveItems = true;
-        break;
-      }
+class PlaceholderPlugin extends ProseMirrorPlugin {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _buildDecorations);
+  }
+  buildProps() {
+    return { decorations: __privateMethod(this, _buildDecorations, buildDecorations_fn).bind(this) };
   }
-  return cachedPreserveItems;
 }
-const historyKey = new PluginKey("history");
-const closeHistoryKey = new PluginKey("closeHistory");
-function history(config = {}) {
-  config = {
-    depth: config.depth || 100,
-    newGroupDelay: config.newGroupDelay || 500
-  };
-  return new Plugin({
-    key: historyKey,
-    state: {
-      init() {
-        return new HistoryState(Branch.empty, Branch.empty, null, 0);
-      },
-      apply(tr, hist, state) {
-        return applyTransaction(hist, state, tr, config);
-      }
-    },
-    config,
-    props: {
-      handleDOMEvents: {
-        beforeinput(view, e) {
-          let inputType = e.inputType;
-          let command2 = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
-          if (!command2)
-            return false;
-          e.preventDefault();
-          return command2(view.state, view.dispatch);
-        }
-      }
+_buildDecorations = new WeakSet();
+buildDecorations_fn = function({ doc: doc2 }) {
+  const decorations = [];
+  if (!this.editor.isEditable)
+    return null;
+  if (doc2.childCount > 1)
+    return;
+  doc2.descendants((node, pos) => {
+    if (!node.childCount) {
+      const decoration = Decoration.node(pos, pos + node.nodeSize, {
+        class: "zw-wysiwyg__placeholder",
+        "data-placeholder": "Type your text here..."
+      });
+      decorations.push(decoration);
     }
-  });
-}
-const undo = (state, dispatch) => {
-  let hist = historyKey.getState(state);
-  if (!hist || hist.done.eventCount == 0)
-    return false;
-  if (dispatch)
-    histTransaction(hist, state, dispatch, false);
-  return true;
-};
-const redo = (state, dispatch) => {
-  let hist = historyKey.getState(state);
-  if (!hist || hist.undone.eventCount == 0)
     return false;
-  if (dispatch)
-    histTransaction(hist, state, dispatch, true);
-  return true;
+  });
+  return DecorationSet.create(doc2, decorations);
 };
-const History = Extension.create({
-  name: "history",
-  addOptions() {
-    return {
-      depth: 100,
-      newGroupDelay: 500
-    };
-  },
+const ProseMirrorPlugins = Extension.create({
+  name: "prose_mirror_plugins",
+  addProseMirrorPlugins() {
+    return [
+      PastePlugin.create(this.editor),
+      PlaceholderPlugin.create(this.editor)
+    ];
+  }
+});
+const buildCoreExtensions = () => [
+  Document,
+  Paragraph,
+  Heading,
+  Text$1,
+  History,
+  NodeProcessor,
+  TextProcessor,
+  SelectionProcessor,
+  ProseMirrorPlugins
+];
+const FontFamily = Mark.create({
+  name: TextSettings.FONT_FAMILY,
+  group: MarkGroups.SETTINGS,
+  addOptions: () => ({
+    fonts: []
+  }),
+  addAttributes: () => ({
+    value: { required: true }
+  }),
   addCommands() {
     return {
-      undo: () => ({ state, dispatch }) => {
-        return undo(state, dispatch);
-      },
-      redo: () => ({ state, dispatch }) => {
-        return redo(state, dispatch);
-      }
+      applyFontFamily: createCommand(({ commands: commands2 }, value) => {
+        commands2.applyMark(this.name, { value });
+        const font = commands2.findFontByName(value);
+        let fontWeight = unref(commands2.getFontWeight());
+        if (!font.isWeightSupported(fontWeight)) {
+          fontWeight = font.findClosestWeight(fontWeight);
+          commands2.applyFontWeight(fontWeight);
+        }
+        if (!font.isItalicSupported(fontWeight)) {
+          commands2.removeItalic();
+        }
+      }),
+      getFont: createCommand(({ commands: commands2 }) => {
+        const defaultPreset = unref(this.options.defaultPreset);
+        const defaultFont = commands2.findFontByName(defaultPreset.common.font_family);
+        const fontFamily = commands2.getFontFamily();
+        return computed(() => commands2.findFontByName(unref(fontFamily)) || defaultFont);
+      }),
+      findFontByName: createCommand((_, name) => {
+        return this.options.fonts.find((font) => font.name === name);
+      }),
+      getFontFamily: createCommand(({ commands: commands2 }) => {
+        return commands2.getCommonSettingMark(this.name, commands2.getDefaultFontFamily());
+      }),
+      getDefaultFontFamily: createCommand(({ commands: commands2 }) => {
+        const preset = commands2.getPreset();
+        return computed(() => unref(preset).common.font_family);
+      })
     };
   },
-  addProseMirrorPlugins() {
+  parseHTML() {
+    const getAttrs = (input) => ({ value: input.replace(/["']/g, "") });
     return [
-      history(this.options)
+      {
+        style: "--zw-font-family",
+        getAttrs
+      },
+      {
+        style: "font-family",
+        getAttrs
+      }
     ];
   },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-z": () => this.editor.commands.undo(),
-      "Mod-y": () => this.editor.commands.redo(),
-      "Shift-Mod-z": () => this.editor.commands.redo(),
-      "Mod-\u044F": () => this.editor.commands.undo(),
-      "Shift-Mod-\u044F": () => this.editor.commands.redo()
-    };
+  renderHTML({ HTMLAttributes: attrs }) {
+    const font_family = attrs.value ? `"${attrs.value}"` : null;
+    return renderMark({ font_family });
   }
 });
-class RemoveNodeMarkStep extends Step {
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number") {
-      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-    }
-    return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-  }
-  constructor(pos, mark) {
-    super();
-    this.pos = pos;
-    this.mark = mark;
-  }
-  apply(doc2) {
-    const node = doc2.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at mark step's position");
-    const updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
-    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
-    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
-  }
-  invert(doc2) {
-    const node = doc2.nodeAt(this.pos);
-    if (!node || !this.mark.isInSet(node.marks))
-      return this;
-    return new AddNodeMarkStep(this.pos, this.mark);
-  }
-  map(mapping) {
-    const pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-  }
-}
-Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
-class AddNodeMarkStep extends Step {
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number") {
-      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-    }
-    return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-  }
-  constructor(pos, mark) {
-    super();
-    this.pos = pos;
-    this.mark = mark;
-  }
-  apply(doc2) {
-    const node = doc2.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at mark step's position");
-    const updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
-    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
-    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
-  }
-  invert(doc2) {
-    const node = doc2.nodeAt(this.pos);
-    if (node) {
-      const newSet = this.mark.addToSet(node.marks);
-      if (newSet.length === node.marks.length) {
-        for (const mark of node.marks) {
-          if (!mark.isInSet(newSet)) {
-            return new AddNodeMarkStep(this.pos, mark);
+const StylePreset = Extension.create({
+  name: TextSettings.STYLE_PRESET,
+  addGlobalAttributes() {
+    return [
+      {
+        types: [NodeTypes.PARAGRAPH, NodeTypes.HEADING],
+        attributes: {
+          preset: {
+            isRequired: false,
+            default: { id: this.options.defaultId },
+            parseHTML: (element) => {
+              const presets = unref(this.options.presets);
+              if (element.parentElement.tagName === "LI")
+                return null;
+              for (const { id: id2, node, fallbackClass } of presets) {
+                if (fallbackClass && element.classList.contains(fallbackClass)) {
+                  return { id: id2 };
+                }
+                const presetSelector = this.options.styleRenderer.makePresetCssClass({ id: id2 });
+                if (element.matches(presetSelector))
+                  return { id: id2 };
+                if (element.tagName === `H${node == null ? void 0 : node.level}`)
+                  return { id: id2 };
+              }
+              return element.tagName === "P" ? { id: this.options.defaultId } : null;
+            },
+            renderHTML: (attrs) => {
+              if (!attrs.preset)
+                return null;
+              return { class: this.options.styleRenderer.makePresetHtmlClass(attrs.preset) };
+            }
           }
         }
-        return new AddNodeMarkStep(this.pos, this.mark);
       }
+    ];
+  },
+  addCommands() {
+    function findPresetById(presets, id2) {
+      return presets.find((preset) => id2 === preset.id);
     }
-    return new RemoveNodeMarkStep(this.pos, this.mark);
-  }
-  map(mapping) {
-    const pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
-  }
-  toJSON() {
-    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-  }
-}
-Step.jsonID("addNodeMark", AddNodeMarkStep);
-class AttrStep extends Step {
-  static fromJSON(schema, json) {
-    if (typeof json.pos != "number" || typeof json.attr != "string") {
-      throw new RangeError("Invalid input for AttrStep.fromJSON");
+    function mergeSettings(source, target) {
+      const settings = {};
+      for (const name of Object.keys(source)) {
+        const sourceValue = source[name];
+        const targetValue = target[name];
+        const isInherit = !targetValue || targetValue.toLowerCase() === "inherit";
+        settings[name] = isInherit ? sourceValue : targetValue;
+      }
+      return settings;
     }
-    return new AttrStep(json.pos, json.attr, json.value);
-  }
-  constructor(pos, attr, value) {
-    super();
-    this.pos = pos;
-    this.attr = attr;
-    this.value = value;
-  }
-  apply(doc2) {
-    const node = doc2.nodeAt(this.pos);
-    if (!node)
-      return StepResult.fail("No node at attribute step's position");
-    const attrs = /* @__PURE__ */ Object.create(null);
-    for (let name in node.attrs)
-      attrs[name] = node.attrs[name];
-    attrs[this.attr] = this.value;
-    const updated = node.type.create(attrs, null, node.marks);
-    const slice2 = new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1);
-    return StepResult.fromReplace(doc2, this.pos, this.pos + 1, slice2);
-  }
-  getMap() {
-    return StepMap.empty;
-  }
-  invert(doc2) {
-    return new AttrStep(this.pos, this.attr, doc2.nodeAt(this.pos).attrs[this.attr]);
-  }
-  map(mapping) {
-    let pos = mapping.mapResult(this.pos, 1);
-    return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
-  }
-  toJSON() {
-    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
-  }
-}
-Step.jsonID("attr", AttrStep);
-const NodeProcessor = Extension.create({
-  name: "node_processor",
-  addCommands() {
     return {
-      setBlockAttributes: createCommand(({ commands: commands2, state }, name, attrs, defaults2 = {}) => {
-        var _a;
-        const current = (_a = unref(commands2.getBlockAttributes(name))) != null ? _a : {};
-        const { doc: doc2, tr } = state;
-        const { from: from2, to } = tr.selection;
-        doc2.nodesBetween(from2, to, (node, position) => {
-          if (!NodeTypes.blocks.includes(node.type.name))
-            return;
-          tr.step(new AttrStep(position, name, { ...defaults2, ...current, ...attrs }));
+      getPresetList: createCommand(() => computed(() => {
+        return this.options.presets.filter((preset) => !preset.hidden);
+      })),
+      getPreset: createCommand(({ commands: commands2 }) => {
+        const selectionRef = commands2.getBlockAttributes("preset", { id: this.options.defaultId });
+        const presetsRef = commands2.getPresetList();
+        const isLinkRef = commands2.isLink();
+        const linkPresetRef = commands2.getLinkPreset();
+        return computed(() => {
+          const preset = findPresetById(unref(presetsRef), unref(selectionRef).id);
+          if (!unref(isLinkRef))
+            return preset;
+          const linkPreset = unref(linkPresetRef);
+          return {
+            id: preset.id,
+            common: mergeSettings(preset.common, linkPreset.common),
+            mobile: mergeSettings(preset.mobile, linkPreset.mobile),
+            tablet: mergeSettings(preset.tablet, linkPreset.tablet),
+            desktop: mergeSettings(preset.desktop, linkPreset.desktop)
+          };
         });
       }),
-      getBlockAttributes: createCommand(({ editor }, name, defaults2) => computed(() => {
-        var _a;
-        let attrs = Object.assign({}, defaults2 || {});
-        for (const type of NodeTypes.blocks) {
-          Object.assign(attrs, ((_a = editor.getAttributes(type)) == null ? void 0 : _a[name]) || {});
+      applyPreset: createCommand(({ commands: commands2, chain }, presetId) => {
+        var _a, _b;
+        const presets = unref(commands2.getPresetList());
+        const preset = findPresetById(presets, presetId);
+        const nodeType = (_b = (_a = preset.node) == null ? void 0 : _a.type) != null ? _b : NodeTypes.PARAGRAPH;
+        const attrs = {
+          preset: { id: presetId }
+        };
+        if (preset.node) {
+          attrs.level = preset.node.level;
         }
-        return Object.keys(attrs).length ? attrs : null;
-      })),
-      removeBlockAttributes: createCommand(({ commands: commands2 }, names) => {
-        for (const type of NodeTypes.blocks) {
-          commands2.resetAttributes(type, names);
+        for (const textAttribute of TextSettings.attributes) {
+          attrs[textAttribute] = unref(commands2.getBlockAttributes(textAttribute));
         }
+        chain().removeList().setNode(nodeType, attrs).run();
       }),
-      applyMark: createCommand(({ state, commands: commands2 }, name, value, customizer = {}) => {
-        const { tr, doc: doc2, schema } = state;
-        const { $from, $to } = tr.selection;
-        const markType = getMarkType(name, schema);
-        const markGroup = markType.spec.group || "";
-        if (!markGroup.includes(MarkGroups.SETTINGS)) {
-          return commands2.setMark(name, value);
-        }
-        if ($from.pos === $to.pos)
-          return;
-        const onAppliedToParent = (context) => {
-          if (!customizer.onAppliedToParent || customizer.onAppliedToParent(context) === false) {
-            const { tr: tr2, node, position, mark } = context;
-            commands2._removeNodeMark({ tr: tr2, node, position, mark: mark.type });
-          }
-        };
-        doc2.nodesBetween($from.pos, $to.pos, (node, position) => {
-          if (node.type.name === NodeTypes.LIST)
-            return;
-          const initialMark = findMarkByType(node.marks, name);
-          const applyingMark = markType.create({ ...(initialMark == null ? void 0 : initialMark.attrs) || {}, ...value });
-          const textPosition = resolveTextPosition($from, $to, node, position);
-          if (isMarkAppliedToParent(tr.doc, position, applyingMark, customizer.isAppliedToParent)) {
-            return onAppliedToParent({ tr, node, position, mark: applyingMark });
-          }
-          if (node.isText) {
-            tr.addMark(textPosition.from, textPosition.to, applyingMark);
-            return;
-          }
-          if (isNodeFullySelected(tr.doc, tr.selection, node, position)) {
-            tr.step(new AddNodeMarkStep(position, applyingMark));
-          }
-        });
+      applyDefaultPreset: createCommand(({ commands: commands2 }) => {
+        commands2.applyPreset(this.options.defaultId);
       }),
-      getMarks: createCommand(({ editor }, name) => {
-        const stateRef = toRef(editor, "state");
-        return computed(() => {
-          const { selection, doc: doc2 } = unref(stateRef);
-          const { from: from2, to } = unref(selection);
-          const marks = [];
-          doc2.nodesBetween(from2, to, (node) => {
-            for (const mark of node.marks) {
-              if (mark.type.name === name)
-                marks.unshift(mark.attrs);
-            }
-          });
-          return marks;
-        });
+      removePreset: createCommand(({ commands: commands2 }) => {
+        commands2.setNode(NodeTypes.PARAGRAPH, { preset: null });
       }),
-      getMark: createCommand(({ commands: commands2 }, name) => {
-        const marksRef = commands2.getMarks(name);
+      getPresetCustomization: createCommand(({ editor, commands: commands2 }) => {
+        const state = toRef(editor, "state");
         return computed(() => {
-          var _a;
-          return (_a = unref(marksRef)[0]) != null ? _a : null;
+          const { selection, doc: doc2 } = unref(state);
+          const { from: from2, to } = selection;
+          return commands2._getSettingCustomization(doc2, from2, to);
         });
       }),
-      hasMark: createCommand(({ commands: commands2 }, name) => {
-        const mark = commands2.getMark(name);
-        return computed(() => !!unref(mark));
-      }),
-      getCommonSettingMark: createCommand(({ commands: commands2 }, name, defaultRef) => {
-        const selectionRef = commands2.getMark(name);
+      isSettingCustomized: createCommand(({ commands: commands2 }, name) => {
+        const customization = commands2.getPresetCustomization();
+        const group = TextSettings.attributes.includes(name) ? "attributes" : "marks";
         return computed(() => {
           var _a, _b;
-          return (_b = (_a = unref(selectionRef)) == null ? void 0 : _a.value) != null ? _b : unref(defaultRef);
+          return (_b = (_a = unref(customization)[group]) == null ? void 0 : _a.includes(name)) != null ? _b : false;
         });
       }),
-      getDeviceSettingMark: createCommand(({ commands: commands2 }, name, defaultRef) => {
-        const selectionRef = commands2.getMarks(name);
-        const deviceRef = commands2.getDevice();
+      getContentCustomization: createCommand(({ editor, commands: commands2 }) => {
+        const state = toRef(editor, "state");
         return computed(() => {
-          for (const attrs of unref(selectionRef)) {
-            const value = attrs[unref(deviceRef)];
-            if (value)
-              return value;
-          }
-          return unref(defaultRef);
-        });
-      }),
-      removeAllMarks: createCommand(({ state, commands: commands2 }) => {
-        const { tr, doc: doc2 } = state;
-        const { from: from2, to } = tr.selection;
-        doc2.nodesBetween(from2, to, (node, position) => {
-          for (const mark of node.marks) {
-            commands2._removeNodeMark({ tr, node, position, mark });
-          }
+          const { doc: doc2 } = unref(state);
+          return commands2._getSettingCustomization(doc2, 0, doc2.content.size);
         });
       }),
-      removeMarks: createCommand(({ state, commands: commands2 }, marks) => {
-        const { tr, doc: doc2 } = state;
-        const { from: from2, to } = tr.selection;
-        doc2.nodesBetween(from2, to, (node, position) => {
-          const removingMarks = node.marks.filter((mark) => marks.includes(mark.type.name));
-          for (const mark of removingMarks) {
-            commands2._removeNodeMark({ tr, node, position, mark });
+      _getSettingCustomization: createCommand((_, doc2, from2, to) => {
+        const marks = /* @__PURE__ */ new Set();
+        const attributes = /* @__PURE__ */ new Set();
+        doc2.nodesBetween(from2, to, (node) => {
+          for (const [name, value] of Object.entries(node.attrs)) {
+            const isSetting = TextSettings.attributes.includes(name);
+            if (isSetting && value)
+              attributes.add(name);
           }
-        });
-      }),
-      _removeNodeMark: createCommand((context, { tr, node, position, mark }) => {
-        return node.isText ? tr.removeMark(position, position + node.nodeSize, mark) : tr.step(new RemoveNodeMarkStep(position, mark));
-      })
-    };
-  }
-});
-const TextProcessor = Extension.create({
-  name: "text_processor",
-  addCommands() {
-    return {
-      getSelectedText: createCommand(({ state }) => {
-        const { from: from2, to } = state.selection;
-        return state.doc.textBetween(from2, to, " ");
-      }),
-      transformText: createCommand(({ state }, transform) => {
-        const { $from, $to } = state.tr.selection;
-        if ($from.pos === $to.pos)
-          return;
-        state.doc.nodesBetween($from.pos, $to.pos, (node, position) => {
-          if (!node.isText)
-            return;
-          const textPosition = resolveTextPosition($from, $to, node, position);
-          const substringFrom = Math.max(0, $from.pos - position);
-          const substringTo = Math.max(0, $to.pos - position);
-          const updatedText = transform({
-            text: node.textContent.substring(substringFrom, substringTo)
-          });
-          const updatedNode = state.schema.text(updatedText, node.marks);
-          state.tr.replaceWith(textPosition.from, textPosition.to, updatedNode);
-        });
-      })
-    };
-  }
-});
-const SelectionProcessor = Extension.create({
-  name: "selection_processor",
-  addStorage: () => ({
-    selection: null
-  }),
-  addCommands() {
-    return {
-      storeSelection: createCommand(({ state }) => {
-        this.storage.selection = state.selection;
-      }),
-      restoreSelection: createCommand(({ commands: commands2 }) => {
-        this.storage.selection && commands2.setTextSelection(this.storage.selection);
-      }),
-      expandSelection: createCommand(({ tr, commands: commands2 }, predicate) => {
-        let from2 = tr.selection.from;
-        let to = tr.selection.to;
-        tr.doc.nodesBetween(from2, to, (node, position, parent) => {
-          if (predicate({ node, parent })) {
-            const offset2 = node.isText ? 0 : resolvePositionOffset(tr.doc, position);
-            from2 = Math.min(from2, position + offset2);
-            to = Math.max(to, position + node.nodeSize - offset2);
+          for (const { type } of node.marks) {
+            if (TextSettings.marks.includes(type.name)) {
+              marks.add(type.name);
+            }
           }
         });
-        commands2.setTextSelection({ from: from2, to });
-      }),
-      expandSelectionToBlock: createCommand(({ commands: commands2 }) => {
-        commands2.expandSelection(({ parent }) => parent.type.name === NodeTypes.DOCUMENT);
-      })
-    };
-  }
-});
-const Document$1 = Node.create({
-  name: "doc",
-  topNode: true,
-  content: "block+"
-});
-const Document = Document$1.extend({
-  marks: MarkGroups.SETTINGS
-});
-const Paragraph$1 = Node.create({
-  name: "paragraph",
-  priority: 1e3,
-  addOptions() {
-    return {
-      HTMLAttributes: {}
-    };
-  },
-  group: "block",
-  content: "inline*",
-  parseHTML() {
-    return [
-      { tag: "p" }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ["p", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  addCommands() {
-    return {
-      setParagraph: () => ({ commands: commands2 }) => {
-        return commands2.setNode(this.name);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Alt-0": () => this.editor.commands.setParagraph()
-    };
-  }
-});
-const Paragraph = Paragraph$1.extend({
-  marks: MarkGroups.ALL,
-  addOptions: () => ({
-    HTMLAttributes: { class: "zw-style" }
-  })
-});
-const Heading$1 = Node.create({
-  name: "heading",
-  addOptions() {
-    return {
-      levels: [1, 2, 3, 4, 5, 6],
-      HTMLAttributes: {}
-    };
-  },
-  content: "inline*",
-  group: "block",
-  defining: true,
-  addAttributes() {
-    return {
-      level: {
-        default: 1,
-        rendered: false
-      }
+        return {
+          attributes: Array.from(attributes),
+          marks: Array.from(marks)
+        };
+      }),
+      removePresetCustomization: createCommand(({ chain }) => {
+        chain().storeSelection().expandSelectionToBlock().removeMarks(TextSettings.marks).resetAttributes(NodeTypes.PARAGRAPH, TextSettings.attributes).resetAttributes(NodeTypes.HEADING, TextSettings.attributes).restoreSelection().run();
+      }),
+      removeFormat: createCommand(({ chain }) => {
+        chain().storeSelection().expandSelectionToBlock().removeAllMarks().applyDefaultPreset().restoreSelection().run();
+      })
     };
   },
-  parseHTML() {
-    return this.options.levels.map((level) => ({
-      tag: `h${level}`,
-      attrs: { level }
-    }));
-  },
-  renderHTML({ node, HTMLAttributes }) {
-    const hasLevel = this.options.levels.includes(node.attrs.level);
-    const level = hasLevel ? node.attrs.level : this.options.levels[0];
-    return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
+  onCreate() {
+    this.options.styleRenderer.inject(ContextWindow.head, this.options.presets);
+  }
+});
+const FontWeight = Mark.create({
+  name: TextSettings.FONT_WEIGHT,
+  group: MarkGroups.SETTINGS,
+  addAttributes: () => ({
+    value: { required: true }
+  }),
   addCommands() {
     return {
-      setHeading: (attributes) => ({ commands: commands2 }) => {
-        if (!this.options.levels.includes(attributes.level)) {
-          return false;
-        }
-        return commands2.setNode(this.name, attributes);
-      },
-      toggleHeading: (attributes) => ({ commands: commands2 }) => {
-        if (!this.options.levels.includes(attributes.level)) {
-          return false;
+      applyFontWeight: createCommand(({ commands: commands2 }, value) => {
+        commands2.applyMark(this.name, { value });
+        const font = unref(commands2.getFont());
+        if (!font.isItalicSupported(value)) {
+          commands2.removeItalic();
         }
-        return commands2.toggleNode(this.name, "paragraph", attributes);
-      }
+      }),
+      toggleBold: createCommand(({ commands: commands2 }) => {
+        const currentWeight = unref(commands2.getFontWeight());
+        const currentFont = unref(commands2.getFont());
+        const isBold = Number(currentWeight) >= 600;
+        const wantedWeight = isBold ? "400" : "700";
+        const nextWeight = currentFont.findClosestWeight(wantedWeight);
+        commands2.applyFontWeight(nextWeight);
+      }),
+      getFontWeight: createCommand(({ commands: commands2 }) => {
+        const selectionRef = commands2.getCommonSettingMark(this.name, commands2.getDefaultFontWeight());
+        const fontRef = commands2.getFont();
+        return computed(() => {
+          const weight = unref(selectionRef);
+          const font = unref(fontRef);
+          return font.isWeightSupported(weight) ? weight : font.findClosestWeight(weight);
+        });
+      }),
+      getDefaultFontWeight: createCommand(({ commands: commands2 }) => {
+        const preset = commands2.getPreset();
+        return computed(() => unref(preset).common.font_weight);
+      })
     };
   },
-  addKeyboardShortcuts() {
-    return this.options.levels.reduce((items, level) => ({
-      ...items,
-      ...{
-        [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
-      }
-    }), {});
-  },
-  addInputRules() {
-    return this.options.levels.map((level) => {
-      return textblockTypeInputRule({
-        find: new RegExp(`^(#{1,${level}})\\s$`),
-        type: this.type,
-        getAttributes: {
-          level
-        }
-      });
-    });
-  }
-});
-const Heading = Heading$1.extend({
-  marks: MarkGroups.ALL,
-  addOptions: () => ({
-    levels: [1, 2, 3, 4],
-    HTMLAttributes: { class: "zw-style" }
-  })
-});
-class ProseMirrorPlugin {
-  static create(editor, options) {
-    const plugin = new this(editor, options || {});
-    return new Plugin({
-      key: new PluginKey(this.name),
-      props: plugin.buildProps()
-    });
-  }
-  constructor(editor, options) {
-    this.options = options;
-    this.editor = editor;
-  }
-  buildProps() {
-    return {};
-  }
-}
-class PastePlugin extends ProseMirrorPlugin {
-  buildProps() {
-    return {
-      transformPastedHTML: this._transformPastedHTML.bind(this),
-      handlePaste: this._handlePaste.bind(this)
+  addKeyboardShortcuts: () => ({
+    "Mod-b": createKeyboardShortcut("toggleBold"),
+    "Mod-B": createKeyboardShortcut("toggleBold")
+  }),
+  parseHTML() {
+    const getAttrs = (value) => {
+      if (value === "bold")
+        return { value: "700" };
+      return Number(value) ? { value } : false;
     };
-  }
-  _transformPastedHTML(html2) {
-    if (html2.includes("data-pm-slice") && html2.includes("zw-style")) {
-      return html2;
-    }
-    const normalizer = ContentNormalizer.build(html2);
-    normalizer.normalizeHTML();
-    this._removeDeprecatedStyles(normalizer);
-    return normalizer.normalizedHTML;
-  }
-  _removeDeprecatedStyles(normalizer) {
-    const elements = normalizer.dom.querySelectorAll('[style*="margin"]');
-    for (const element of Array.from(elements)) {
-      element.style.removeProperty("margin");
-      element.style.removeProperty("margin-top");
-      element.style.removeProperty("margin-right");
-      element.style.removeProperty("margin-bottom");
-      element.style.removeProperty("margin-left");
-    }
-  }
-  _handlePaste(view, _, slice2) {
-    const transaction = this._insertPastedContent(view, slice2).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste");
-    view.dispatch(transaction);
-    return true;
-  }
-  _insertPastedContent({ state, input }, slice2) {
-    if (!this._isFullBlockSelected(state)) {
-      return state.tr.replaceSelection(slice2);
-    }
-    return state.tr.replaceSelectionWith(slice2.content, input.shiftKey);
-  }
-  _isFullBlockSelected(state) {
-    const blocksSelection = this._expandSelectionToBlocks(state);
-    const isFromMatch = this._isMatchPosition(blocksSelection.from, state.selection.from);
-    const isToMatch = this._isMatchPosition(blocksSelection.to, state.selection.to);
-    return isFromMatch && isToMatch;
-  }
-  _expandSelectionToBlocks({ selection, doc: doc2 }) {
-    let from2 = selection.from;
-    let to = selection.to;
-    doc2.nodesBetween(from2, to, (node, position, parent) => {
-      if (parent.type.name !== NodeTypes.DOCUMENT)
-        return;
-      from2 = Math.min(from2, position + 1);
-      to = Math.max(to, position + node.nodeSize - 1);
-    });
-    return { from: from2, to };
-  }
-  _isMatchPosition(position1, position2) {
-    return Math.abs(position1 - position2) < 5;
-  }
-}
-class PlaceholderPlugin extends ProseMirrorPlugin {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _buildDecorations);
-  }
-  buildProps() {
-    return { decorations: __privateMethod(this, _buildDecorations, buildDecorations_fn).bind(this) };
-  }
-}
-_buildDecorations = new WeakSet();
-buildDecorations_fn = function({ doc: doc2 }) {
-  const decorations = [];
-  if (!this.editor.isEditable)
-    return null;
-  if (doc2.childCount > 1)
-    return;
-  doc2.descendants((node, pos) => {
-    if (!node.childCount) {
-      const decoration = Decoration.node(pos, pos + node.nodeSize, {
-        class: "zw-wysiwyg__placeholder",
-        "data-placeholder": "Type your text here..."
-      });
-      decorations.push(decoration);
-    }
-    return false;
-  });
-  return DecorationSet.create(doc2, decorations);
-};
-const ProseMirrorPlugins = Extension.create({
-  name: "prose_mirror_plugins",
-  addProseMirrorPlugins() {
     return [
-      PastePlugin.create(this.editor),
-      PlaceholderPlugin.create(this.editor)
+      {
+        style: "--zw-font-weight",
+        getAttrs
+      },
+      {
+        style: "font-weight",
+        getAttrs
+      },
+      {
+        tag: "b",
+        attrs: { value: "700" }
+      },
+      {
+        tag: "strong",
+        attrs: { value: "700" }
+      }
     ];
+  },
+  renderHTML({ HTMLAttributes: attrs }) {
+    return renderMark({ font_weight: attrs.value });
   }
 });
-const buildCoreExtensions = () => [
-  Document,
-  Paragraph,
-  Heading,
-  Text$1,
-  History,
-  NodeProcessor,
-  TextProcessor,
-  SelectionProcessor,
-  ProseMirrorPlugins
-];
 const FontSize = Mark.create({
   name: TextSettings.FONT_SIZE,
   group: MarkGroups.SETTINGS,
@@ -14774,9 +14748,9 @@ const Alignment = Extension.create({
             if (textAlign) {
               return { desktop: textAlign, tablet: textAlign, mobile: textAlign };
             }
-            const mobile = style2.getPropertyValue("--zw-text-align-mobile") || null;
-            const tablet = style2.getPropertyValue("--zw-text-align-tablet") || null;
-            const desktop = style2.getPropertyValue("--zw-text-align-desktop") || null;
+            const mobile = style2.getPropertyValue("--zw-alignment-mobile") || null;
+            const tablet = style2.getPropertyValue("--zw-alignment-tablet") || null;
+            const desktop = style2.getPropertyValue("--zw-alignment-desktop") || null;
             if (!mobile && !tablet && !desktop)
               return null;
             return { desktop, tablet, mobile };
@@ -14785,9 +14759,9 @@ const Alignment = Extension.create({
             if (!attrs.alignment)
               return null;
             return renderInlineSetting({
-              text_align_mobile: attrs.alignment.mobile,
-              text_align_tablet: attrs.alignment.tablet,
-              text_align_desktop: attrs.alignment.desktop
+              alignment_mobile: attrs.alignment.mobile,
+              alignment_tablet: attrs.alignment.tablet,
+              alignment_desktop: attrs.alignment.desktop
             });
           }
         }
@@ -16218,8 +16192,11 @@ function buildExtensions(options) {
     StylePreset.configure({
       presets: options.presetsRef,
       defaultId: options.defaultPresetId,
-      baseClass: options.basePresetClass,
-      makeVariable: options.makePresetVariable
+      styleRenderer: new StylePresetRenderer({
+        baseClass: options.basePresetClass,
+        makeVariable: options.makePresetVariable,
+        linkPresetId: options.linkPresetId
+      })
     }),
     List.configure({
       baseClass: options.baseListClass,
@@ -17705,6 +17682,62 @@ const _HtmlToJsonParser = class {
 };
 let HtmlToJsonParser = _HtmlToJsonParser;
 _contentSerializer = new WeakMap();
+class StylePresetRenderer {
+  constructor({ baseClass, makeVariable, linkPresetId }) {
+    __privateAdd(this, _makeInternalVariableName);
+    __privateAdd(this, _baseClass, void 0);
+    __privateAdd(this, _makeVariable, void 0);
+    __privateAdd(this, _linkPresetId, void 0);
+    __privateSet(this, _baseClass, baseClass);
+    __privateSet(this, _makeVariable, makeVariable);
+    __privateSet(this, _linkPresetId, linkPresetId);
+  }
+  inject(hostEl, presets) {
+    let styleEl = hostEl.querySelector("[data-zw-styles]");
+    if (styleEl)
+      return;
+    styleEl = ContextWindow.document.createElement("style");
+    styleEl.dataset.zwStyles = "";
+    styleEl.innerHTML = this.render(presets);
+    hostEl.append(styleEl);
+  }
+  render(presets) {
+    let css = "";
+    for (const preset of presets) {
+      const isLink = preset.id === __privateGet(this, _linkPresetId);
+      const className = this.makePresetCssClass(preset);
+      css += ` ${className} {`;
+      for (const device of Devices.values) {
+        for (const setting of Object.keys(preset[device])) {
+          const variable = __privateGet(this, _makeVariable).call(this, { device, preset, property: setting });
+          const internalVariable = __privateMethod(this, _makeInternalVariableName, makeInternalVariableName_fn).call(this, setting, device);
+          css += `${internalVariable}: var(${variable}, inherit);`;
+          if (isLink) {
+            const overrideVariable = internalVariable.replace("preset-", "");
+            css += `${overrideVariable}: var(${internalVariable});`;
+          }
+        }
+      }
+      css += "}";
+    }
+    return css;
+  }
+  makePresetHtmlClass(preset) {
+    return __privateGet(this, _baseClass) + preset.id;
+  }
+  makePresetCssClass(preset) {
+    return this.makePresetHtmlClass(preset).split(" ").map((part) => `.${part}`).join("");
+  }
+}
+_baseClass = new WeakMap();
+_makeVariable = new WeakMap();
+_linkPresetId = new WeakMap();
+_makeInternalVariableName = new WeakSet();
+makeInternalVariableName_fn = function(setting, device) {
+  const property = setting === "color" ? "font-color" : setting.replace(/_/i, "-");
+  const prefix = device === Devices.COMMON ? "" : `-${device}`;
+  return `--zw-preset-${property}${prefix}`;
+};
 function convertFontSize(value, wrapperEl) {
   if (!value.includes("em"))
     return parseInt(value);
@@ -23656,6 +23689,8 @@ function useModalToggler({ onBeforeOpened, onClosed, wrapperRef, modalRef } = {}
     });
   }
   async function open() {
+    if (isOpened.value)
+      return;
     onBeforeOpened == null ? void 0 : onBeforeOpened();
     editor.commands.storeSelection();
     isOpened.value = true;
@@ -24453,7 +24488,7 @@ var __component__$v = /* @__PURE__ */ normalizeComponent(
   staticRenderFns$v,
   false,
   __vue2_injectStyles$v,
-  "eeca926a",
+  "bb5c4efe",
   null,
   null
 );
@@ -25087,7 +25122,7 @@ var __component__$o = /* @__PURE__ */ normalizeComponent(
   staticRenderFns$o,
   false,
   __vue2_injectStyles$o,
-  "3739e310",
+  "1f333e30",
   null,
   null
 );