@bendyline/squisq-editor-react 2.4.1 → 2.4.3

package/dist/{chunk-KR4VLXUM.js → chunk-JGW6BJZJ.js}

@@ -15,7 +15,7 @@ import {
 import {
   RecorderPanel,
   useModalDialog
-} from "./chunk-LOTY7AOS.js";
+} from "./chunk-PKGBWNUQ.js";
 import {
   Icon
 } from "./chunk-GS7QWYFT.js";
@@ -4463,8 +4463,8 @@ function PreviewModeMenu({ openRequest = 0 }) {
   useLayoutEffect(() => {
     if (!open || !anchor) return;
     const selected = menuRef.current?.querySelector('[aria-checked="true"]');
-    const first2 = menuRef.current?.querySelector('[role="menuitemradio"]');
-    (selected ?? first2)?.focus();
+    const first = menuRef.current?.querySelector('[role="menuitemradio"]');
+    (selected ?? first)?.focus();
   }, [anchor, open]);
   return /* @__PURE__ */ jsxs6(Fragment3, { children: [
     /* @__PURE__ */ jsx8(
@@ -11441,2159 +11441,9 @@ function SceneToolbar({
   )) });
 }
 
-// ../../node_modules/@tiptap/core/dist/index.js
-import { Plugin, PluginKey, TextSelection, Selection, AllSelection, NodeSelection, EditorState } from "@tiptap/pm/state";
-import { EditorView } from "@tiptap/pm/view";
-import { keymap } from "@tiptap/pm/keymap";
-import { Schema, DOMSerializer, Fragment as Fragment6, Node as Node$1, DOMParser, Slice } from "@tiptap/pm/model";
-import { liftTarget, ReplaceStep, ReplaceAroundStep, joinPoint, Transform, canSplit, canJoin, findWrapping } from "@tiptap/pm/transform";
-import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinUp as joinUp$1, joinDown as joinDown$1, joinBackward as joinBackward$1, joinForward as joinForward$1, joinTextblockBackward as joinTextblockBackward$1, joinTextblockForward as joinTextblockForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from "@tiptap/pm/commands";
-import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from "@tiptap/pm/schema-list";
-function createChainableState(config3) {
-  const { state, transaction } = config3;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-var CommandManager = class {
-  constructor(props) {
-    this.editor = props.editor;
-    this.rawCommands = this.editor.extensionManager.commands;
-    this.customState = props.state;
-  }
-  get hasCustomState() {
-    return !!this.customState;
-  }
-  get state() {
-    return this.customState || this.editor.state;
-  }
-  get commands() {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const { tr } = state;
-    const props = this.buildProps(tr);
-    return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      const method = (...args) => {
-        const callback = command2(...args)(props);
-        if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
-          view.dispatch(tr);
-        }
-        return callback;
-      };
-      return [name, method];
-    }));
-  }
-  get chain() {
-    return () => this.createChain();
-  }
-  get can() {
-    return () => this.createCan();
-  }
-  createChain(startTr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const callbacks = [];
-    const hasStartTransaction = !!startTr;
-    const tr = startTr || state.tr;
-    const run = () => {
-      if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
-        view.dispatch(tr);
-      }
-      return callbacks.every((callback) => callback === true);
-    };
-    const chain = {
-      ...Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-        const chainedCommand = (...args) => {
-          const props = this.buildProps(tr, shouldDispatch);
-          const callback = command2(...args)(props);
-          callbacks.push(callback);
-          return chain;
-        };
-        return [name, chainedCommand];
-      })),
-      run
-    };
-    return chain;
-  }
-  createCan(startTr) {
-    const { rawCommands, state } = this;
-    const dispatch = false;
-    const tr = startTr || state.tr;
-    const props = this.buildProps(tr, dispatch);
-    const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-    }));
-    return {
-      ...formattedCommands,
-      chain: () => this.createChain(tr, dispatch)
-    };
-  }
-  buildProps(tr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const props = {
-      tr,
-      editor,
-      view,
-      state: createChainableState({
-        state,
-        transaction: tr
-      }),
-      dispatch: shouldDispatch ? () => void 0 : void 0,
-      chain: () => this.createChain(tr, shouldDispatch),
-      can: () => this.createCan(tr),
-      get commands() {
-        return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)(props)];
-        }));
-      }
-    };
-    return props;
-  }
-};
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
-  }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
-      ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
-    });
-    return value;
-  }
-  return extension.config[field];
-}
-function splitExtensions(extensions) {
-  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
-  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
-  const markExtensions = extensions.filter((extension) => extension.type === "mark");
-  return {
-    baseExtensions,
-    nodeExtensions,
-    markExtensions
-  };
-}
-function getNodeType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.nodes[nameOrType]) {
-      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.nodes[nameOrType];
-  }
-  return nameOrType;
-}
-function mergeAttributes(...objects) {
-  return objects.filter((item) => !!item).reduce((items, item) => {
-    const mergedAttributes = { ...items };
-    Object.entries(item).forEach(([key, value]) => {
-      const exists = mergedAttributes[key];
-      if (!exists) {
-        mergedAttributes[key] = value;
-        return;
-      }
-      if (key === "class") {
-        const valueClasses = value ? String(value).split(" ") : [];
-        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
-        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
-        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
-      } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
-      } else {
-        mergedAttributes[key] = value;
-      }
-    });
-    return mergedAttributes;
-  }, {});
-}
-function isFunction2(value) {
-  return typeof value === "function";
-}
-function callOrReturn(value, context = void 0, ...props) {
-  if (isFunction2(value)) {
-    if (context) {
-      return value.bind(context)(...props);
-    }
-    return value(...props);
-  }
-  return value;
-}
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-var InputRule = class {
-  constructor(config3) {
-    this.find = config3.find;
-    this.handler = config3.handler;
-  }
-};
-function getType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-  if (getType(value) !== "Object") {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  if (isPlainObject(target) && isPlainObject(source)) {
-    Object.keys(source).forEach((key) => {
-      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
-        output[key] = mergeDeep(target[key], source[key]);
-      } else {
-        output[key] = source[key];
-      }
-    });
-  }
-  return output;
-}
-var Extension = class _Extension {
-  constructor(config3 = {}) {
-    this.type = "extension";
-    this.name = "extension";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config3
-    };
-    this.name = this.config.name;
-    if (config3.defaultOptions && Object.keys(config3.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config3 = {}) {
-    return new _Extension(config3);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new _Extension({ ...this.config, ...extendedConfig });
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-};
-function getTextBetween(startNode, range, options) {
-  const { from, to } = range;
-  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-  let text = "";
-  startNode.nodesBetween(from, to, (node2, pos, parent, index2) => {
-    var _a;
-    if (node2.isBlock && pos > from) {
-      text += blockSeparator;
-    }
-    const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node2.type.name];
-    if (textSerializer) {
-      if (parent) {
-        text += textSerializer({
-          node: node2,
-          pos,
-          parent,
-          index: index2,
-          range
-        });
-      }
-      return false;
-    }
-    if (node2.isText) {
-      text += (_a = node2 === null || node2 === void 0 ? void 0 : node2.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-    }
-  });
-  return text;
-}
-function getTextSerializersFromSchema(schema) {
-  return Object.fromEntries(Object.entries(schema.nodes).filter(([, node2]) => node2.spec.toText).map(([name, node2]) => [name, node2.spec.toText]));
-}
-var ClipboardTextSerializer = Extension.create({
-  name: "clipboardTextSerializer",
-  addOptions() {
-    return {
-      blockSeparator: void 0
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("clipboardTextSerializer"),
-        props: {
-          clipboardTextSerializer: () => {
-            const { editor } = this;
-            const { state, schema } = editor;
-            const { doc, selection } = state;
-            const { ranges } = selection;
-            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-            const textSerializers = getTextSerializersFromSchema(schema);
-            const range = { from, to };
-            return getTextBetween(doc, range, {
-              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-              textSerializers
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var blur = () => ({ editor, view }) => {
-  requestAnimationFrame(() => {
-    var _a;
-    if (!editor.isDestroyed) {
-      view.dom.blur();
-      (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-    }
-  });
-  return true;
-};
-var clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-  return commands2.setContent("", emitUpdate);
-};
-var clearNodes = () => ({ state, tr, dispatch }) => {
-  const { selection } = tr;
-  const { ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  ranges.forEach(({ $from, $to }) => {
-    state.doc.nodesBetween($from.pos, $to.pos, (node2, pos) => {
-      if (node2.type.isText) {
-        return;
-      }
-      const { doc, mapping } = tr;
-      const $mappedFrom = doc.resolve(mapping.map(pos));
-      const $mappedTo = doc.resolve(mapping.map(pos + node2.nodeSize));
-      const nodeRange = $mappedFrom.blockRange($mappedTo);
-      if (!nodeRange) {
-        return;
-      }
-      const targetLiftDepth = liftTarget(nodeRange);
-      if (node2.type.isTextblock) {
-        const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
-        tr.setNodeMarkup(nodeRange.start, defaultType);
-      }
-      if (targetLiftDepth || targetLiftDepth === 0) {
-        tr.lift(nodeRange, targetLiftDepth);
-      }
-    });
-  });
-  return true;
-};
-var command = (fn) => (props) => {
-  return fn(props);
-};
-var createParagraphNear = () => ({ state, dispatch }) => {
-  return createParagraphNear$1(state, dispatch);
-};
-var cut = (originRange, targetPos) => ({ editor, tr }) => {
-  const { state } = editor;
-  const contentSlice = state.doc.slice(originRange.from, originRange.to);
-  tr.deleteRange(originRange.from, originRange.to);
-  const newPos = tr.mapping.map(targetPos);
-  tr.insert(newPos, contentSlice.content);
-  tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
-  return true;
-};
-var deleteCurrentNode = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const currentNode = selection.$anchor.node();
-  if (currentNode.content.size > 0) {
-    return false;
-  }
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node2 = $pos.node(depth);
-    if (node2.type === currentNode.type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node2 = $pos.node(depth);
-    if (node2.type === type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var deleteRange = (range) => ({ tr, dispatch }) => {
-  const { from, to } = range;
-  if (dispatch) {
-    tr.delete(from, to);
-  }
-  return true;
-};
-var deleteSelection = () => ({ state, dispatch }) => {
-  return deleteSelection$1(state, dispatch);
-};
-var enter = () => ({ commands: commands2 }) => {
-  return commands2.keyboardShortcut("Enter");
-};
-var exitCode = () => ({ state, dispatch }) => {
-  return exitCode$1(state, dispatch);
-};
-function objectIncludes(object1, object2, options = { strict: true }) {
-  const keys = Object.keys(object2);
-  if (!keys.length) {
-    return true;
-  }
-  return keys.every((key) => {
-    if (options.strict) {
-      return object2[key] === object1[key];
-    }
-    if (isRegExp(object2[key])) {
-      return object2[key].test(object1[key]);
-    }
-    return object2[key] === object1[key];
-  });
-}
-function findMarkInSet(marks, type, attributes = {}) {
-  return marks.find((item) => {
-    return item.type === type && objectIncludes(
-      // Only check equality for the attributes that are provided
-      Object.fromEntries(Object.keys(attributes).map((k2) => [k2, item.attrs[k2]])),
-      attributes
-    );
-  });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-  return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes) {
-  var _a;
-  if (!$pos || !type) {
-    return;
-  }
-  let start = $pos.parent.childAfter($pos.parentOffset);
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    start = $pos.parent.childBefore($pos.parentOffset);
-  }
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    return;
-  }
-  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
-  const mark = findMarkInSet([...start.node.marks], type, attributes);
-  if (!mark) {
-    return;
-  }
-  let startIndex = start.index;
-  let startPos = $pos.start() + start.offset;
-  let endIndex = startIndex + 1;
-  let endPos = startPos + start.node.nodeSize;
-  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
-    startIndex -= 1;
-    startPos -= $pos.parent.child(startIndex).nodeSize;
-  }
-  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
-    endPos += $pos.parent.child(endIndex).nodeSize;
-    endIndex += 1;
-  }
-  return {
-    from: startPos,
-    to: endPos
-  };
-}
-function getMarkType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.marks[nameOrType]) {
-      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.marks[nameOrType];
-  }
-  return nameOrType;
-}
-var extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const type = getMarkType(typeOrName, state.schema);
-  const { doc, selection } = tr;
-  const { $from, from, to } = selection;
-  if (dispatch) {
-    const range = getMarkRange($from, type, attributes);
-    if (range && range.from <= from && range.to >= to) {
-      const newSelection = TextSelection.create(doc, range.from, range.to);
-      tr.setSelection(newSelection);
-    }
-  }
-  return true;
-};
-var first = (commands2) => (props) => {
-  const items = typeof commands2 === "function" ? commands2(props) : commands2;
-  for (let i = 0; i < items.length; i += 1) {
-    if (items[i](props)) {
-      return true;
-    }
-  }
-  return false;
-};
-function isTextSelection(value) {
-  return value instanceof TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = Selection.atStart(doc);
-  const selectionAtEnd = Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-function isSafari() {
-  return typeof navigator !== "undefined" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
-}
-var focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-  options = {
-    scrollIntoView: true,
-    ...options
-  };
-  const delayedFocus = () => {
-    if (isiOS() || isAndroid()) {
-      view.dom.focus();
-    }
-    requestAnimationFrame(() => {
-      if (!editor.isDestroyed) {
-        view.focus();
-        if (isSafari() && !isiOS() && !isAndroid()) {
-          view.dom.focus({ preventScroll: true });
-        }
-      }
-    });
-  };
-  if (view.hasFocus() && position === null || position === false) {
-    return true;
-  }
-  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-    delayedFocus();
-    return true;
-  }
-  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
-  const isSameSelection = editor.state.selection.eq(selection);
-  if (dispatch) {
-    if (!isSameSelection) {
-      tr.setSelection(selection);
-    }
-    if (isSameSelection && tr.storedMarks) {
-      tr.setStoredMarks(tr.storedMarks);
-    }
-    delayedFocus();
-  }
-  return true;
-};
-var forEach = (items, fn) => (props) => {
-  return items.every((item, index2) => fn(item, { ...props, index: index2 }));
-};
-var insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-  return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-var removeWhitespaces = (node2) => {
-  const children = node2.childNodes;
-  for (let i = children.length - 1; i >= 0; i -= 1) {
-    const child = children[i];
-    if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-      node2.removeChild(child);
-    } else if (child.nodeType === 1) {
-      removeWhitespaces(child);
-    }
-  }
-  return node2;
-};
-function elementFromString(value) {
-  const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
-  return removeWhitespaces(html);
-}
-function createNodeFromContent(content, schema, options) {
-  if (content instanceof Node$1 || content instanceof Fragment6) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return Fragment6.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node2 = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node2.check();
-      }
-      return node2;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e2) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e2 === "string" ? e2 : e2.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
-      }
-      if (options.errorOnInvalidContent && hasInvalidContent) {
-        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${invalidContent}`) });
-      }
-    }
-    const parser = DOMParser.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-var isFragment = (nodeOrFragment) => {
-  return !("type" in nodeOrFragment);
-};
-var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-  var _a;
-  if (dispatch) {
-    options = {
-      parseOptions: editor.options.parseOptions,
-      updateSelection: true,
-      applyInputRules: false,
-      applyPasteRules: false,
-      ...options
-    };
-    let content;
-    const emitContentError = (error) => {
-      editor.emit("contentError", {
-        editor,
-        error,
-        disableCollaboration: () => {
-          if (editor.storage.collaboration) {
-            editor.storage.collaboration.isDisabled = true;
-          }
-        }
-      });
-    };
-    const parseOptions = {
-      preserveWhitespace: "full",
-      ...options.parseOptions
-    };
-    if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
-      try {
-        createNodeFromContent(value, editor.schema, {
-          parseOptions,
-          errorOnInvalidContent: true
-        });
-      } catch (e2) {
-        emitContentError(e2);
-      }
-    }
-    try {
-      content = createNodeFromContent(value, editor.schema, {
-        parseOptions,
-        errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-      });
-    } catch (e2) {
-      emitContentError(e2);
-      return false;
-    }
-    let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
-    let isOnlyTextContent = true;
-    let isOnlyBlockContent = true;
-    const nodes = isFragment(content) ? content : [content];
-    nodes.forEach((node2) => {
-      node2.check();
-      isOnlyTextContent = isOnlyTextContent ? node2.isText && node2.marks.length === 0 : false;
-      isOnlyBlockContent = isOnlyBlockContent ? node2.isBlock : false;
-    });
-    if (from === to && isOnlyBlockContent) {
-      const { parent } = tr.doc.resolve(from);
-      const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
-      if (isEmptyTextBlock) {
-        from -= 1;
-        to += 1;
-      }
-    }
-    let newContent;
-    if (isOnlyTextContent) {
-      if (Array.isArray(value)) {
-        newContent = value.map((v2) => v2.text || "").join("");
-      } else if (value instanceof Fragment6) {
-        let text = "";
-        value.forEach((node2) => {
-          if (node2.text) {
-            text += node2.text;
-          }
-        });
-        newContent = text;
-      } else if (typeof value === "object" && !!value && !!value.text) {
-        newContent = value.text;
-      } else {
-        newContent = value;
-      }
-      tr.insertText(newContent, from, to);
-    } else {
-      newContent = content;
-      tr.replaceWith(from, to, newContent);
-    }
-    if (options.updateSelection) {
-      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    if (options.applyInputRules) {
-      tr.setMeta("applyInputRules", { from, text: newContent });
-    }
-    if (options.applyPasteRules) {
-      tr.setMeta("applyPasteRules", { from, text: newContent });
-    }
-  }
-  return true;
-};
-var joinUp = () => ({ state, dispatch }) => {
-  return joinUp$1(state, dispatch);
-};
-var joinDown = () => ({ state, dispatch }) => {
-  return joinDown$1(state, dispatch);
-};
-var joinBackward = () => ({ state, dispatch }) => {
-  return joinBackward$1(state, dispatch);
-};
-var joinForward = () => ({ state, dispatch }) => {
-  return joinForward$1(state, dispatch);
-};
-var joinItemBackward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, -1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-var joinItemForward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, 1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-var joinTextblockBackward = () => ({ state, dispatch }) => {
-  return joinTextblockBackward$1(state, dispatch);
-};
-var joinTextblockForward = () => ({ state, dispatch }) => {
-  return joinTextblockForward$1(state, dispatch);
-};
-function isMacOS() {
-  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-}
-function normalizeKeyName(name) {
-  const parts = name.split(/-(?!$)/);
-  let result = parts[parts.length - 1];
-  if (result === "Space") {
-    result = " ";
-  }
-  let alt;
-  let ctrl;
-  let shift;
-  let meta;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const mod = parts[i];
-    if (/^(cmd|meta|m)$/i.test(mod)) {
-      meta = true;
-    } else if (/^a(lt)?$/i.test(mod)) {
-      alt = true;
-    } else if (/^(c|ctrl|control)$/i.test(mod)) {
-      ctrl = true;
-    } else if (/^s(hift)?$/i.test(mod)) {
-      shift = true;
-    } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS()) {
-        meta = true;
-      } else {
-        ctrl = true;
-      }
-    } else {
-      throw new Error(`Unrecognized modifier name: ${mod}`);
-    }
-  }
-  if (alt) {
-    result = `Alt-${result}`;
-  }
-  if (ctrl) {
-    result = `Ctrl-${result}`;
-  }
-  if (meta) {
-    result = `Meta-${result}`;
-  }
-  if (shift) {
-    result = `Shift-${result}`;
-  }
-  return result;
-}
-var keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
-  const keys = normalizeKeyName(name).split(/-(?!$)/);
-  const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
-  const event = new KeyboardEvent("keydown", {
-    key: key === "Space" ? " " : key,
-    altKey: keys.includes("Alt"),
-    ctrlKey: keys.includes("Ctrl"),
-    metaKey: keys.includes("Meta"),
-    shiftKey: keys.includes("Shift"),
-    bubbles: true,
-    cancelable: true
-  });
-  const capturedTransaction = editor.captureTransaction(() => {
-    view.someProp("handleKeyDown", (f) => f(view, event));
-  });
-  capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach((step) => {
-    const newStep = step.map(tr.mapping);
-    if (newStep && dispatch) {
-      tr.maybeStep(newStep);
-    }
-  });
-  return true;
-};
-function isNodeActive(state, typeOrName, attributes = {}) {
-  const { from, to, empty } = state.selection;
-  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
-  const nodeRanges = [];
-  state.doc.nodesBetween(from, to, (node2, pos) => {
-    if (node2.isText) {
-      return;
-    }
-    const relativeFrom = Math.max(from, pos);
-    const relativeTo = Math.min(to, pos + node2.nodeSize);
-    nodeRanges.push({
-      node: node2,
-      from: relativeFrom,
-      to: relativeTo
-    });
-  });
-  const selectionRange = to - from;
-  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === nodeRange.node.type.name;
-  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
-  if (empty) {
-    return !!matchedNodeRanges.length;
-  }
-  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
-  return range >= selectionRange;
-}
-var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (!isActive) {
-    return false;
-  }
-  return lift$1(state, dispatch);
-};
-var liftEmptyBlock = () => ({ state, dispatch }) => {
-  return liftEmptyBlock$1(state, dispatch);
-};
-var liftListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return liftListItem$1(type)(state, dispatch);
-};
-var newlineInCode = () => ({ state, dispatch }) => {
-  return newlineInCode$1(state, dispatch);
-};
-function getSchemaTypeNameByName(name, schema) {
-  if (schema.nodes[name]) {
-    return "node";
-  }
-  if (schema.marks[name]) {
-    return "mark";
-  }
-  return null;
-}
-function deleteProps(obj, propOrProps) {
-  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
-  return Object.keys(obj).reduce((newObj, prop) => {
-    if (!props.includes(prop)) {
-      newObj[prop] = obj[prop];
-    }
-    return newObj;
-  }, {});
-}
-var resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node2, pos) => {
-        if (nodeType && nodeType === node2.type) {
-          tr.setNodeMarkup(pos, void 0, deleteProps(node2.attrs, attributes));
-        }
-        if (markType && node2.marks.length) {
-          node2.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(pos, pos + node2.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-            }
-          });
-        }
-      });
-    });
-  }
-  return true;
-};
-var scrollIntoView = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    tr.scrollIntoView();
-  }
-  return true;
-};
-var selectAll = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const selection = new AllSelection(tr.doc);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var selectNodeBackward = () => ({ state, dispatch }) => {
-  return selectNodeBackward$1(state, dispatch);
-};
-var selectNodeForward = () => ({ state, dispatch }) => {
-  return selectNodeForward$1(state, dispatch);
-};
-var selectParentNode = () => ({ state, dispatch }) => {
-  return selectParentNode$1(state, dispatch);
-};
-var selectTextblockEnd = () => ({ state, dispatch }) => {
-  return selectTextblockEnd$1(state, dispatch);
-};
-var selectTextblockStart = () => ({ state, dispatch }) => {
-  return selectTextblockStart$1(state, dispatch);
-};
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-var setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands: commands2 }) => {
-  var _a, _b;
-  const { doc } = tr;
-  if (parseOptions.preserveWhitespace !== "full") {
-    const document2 = createDocument(content, editor.schema, parseOptions, {
-      errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-    });
-    if (dispatch) {
-      tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
-    }
-    return true;
-  }
-  if (dispatch) {
-    tr.setMeta("preventUpdate", !emitUpdate);
-  }
-  return commands2.insertContentAt({ from: 0, to: doc.content.size }, content, {
-    parseOptions,
-    errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck
-  });
-};
-function getMarkAttributes(state, typeOrName) {
-  const type = getMarkType(typeOrName, state.schema);
-  const { from, to, empty } = state.selection;
-  const marks = [];
-  if (empty) {
-    if (state.storedMarks) {
-      marks.push(...state.storedMarks);
-    }
-    marks.push(...state.selection.$head.marks());
-  } else {
-    state.doc.nodesBetween(from, to, (node2) => {
-      marks.push(...node2.marks);
-    });
-  }
-  const mark = marks.find((markItem) => markItem.type.name === type.name);
-  if (!mark) {
-    return {};
-  }
-  return { ...mark.attrs };
-}
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i += 1) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type;
-    }
-  }
-  return null;
-}
-function findParentNodeClosestToPos($pos, predicate) {
-  for (let i = $pos.depth; i > 0; i -= 1) {
-    const node2 = $pos.node(i);
-    if (predicate(node2)) {
-      return {
-        pos: i > 0 ? $pos.before(i) : 0,
-        start: $pos.start(i),
-        depth: i,
-        node: node2
-      };
-    }
-  }
-}
-function findParentNode(predicate) {
-  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-  return Object.fromEntries(Object.entries(attributes).filter(([name]) => {
-    const extensionAttribute = extensionAttributes.find((item) => {
-      return item.type === typeName && item.name === name;
-    });
-    if (!extensionAttribute) {
-      return false;
-    }
-    return extensionAttribute.attribute.keepOnSplit;
-  }));
-}
-function isMarkActive(state, typeOrName, attributes = {}) {
-  const { empty, ranges } = state.selection;
-  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
-  if (empty) {
-    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
-      if (!type) {
-        return true;
-      }
-      return type.name === mark.type.name;
-    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
-  }
-  let selectionRange = 0;
-  const markRanges = [];
-  ranges.forEach(({ $from, $to }) => {
-    const from = $from.pos;
-    const to = $to.pos;
-    state.doc.nodesBetween(from, to, (node2, pos) => {
-      if (!node2.isText && !node2.marks.length) {
-        return;
-      }
-      const relativeFrom = Math.max(from, pos);
-      const relativeTo = Math.min(to, pos + node2.nodeSize);
-      const range2 = relativeTo - relativeFrom;
-      selectionRange += range2;
-      markRanges.push(...node2.marks.map((mark) => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo
-      })));
-    });
-  });
-  if (selectionRange === 0) {
-    return false;
-  }
-  const matchedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === markRange.mark.type.name;
-  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const excludedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
-  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
-  return range >= selectionRange;
-}
-function isList(name, extensions) {
-  const { nodeExtensions } = splitExtensions(extensions);
-  const extension = nodeExtensions.find((item) => item.name === name);
-  if (!extension) {
-    return false;
-  }
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage
-  };
-  const group = callOrReturn(getExtensionField(extension, "group", context));
-  if (typeof group !== "string") {
-    return false;
-  }
-  return group.split(" ").includes("list");
-}
-function isNodeEmpty(node2, { checkChildren = true, ignoreWhitespace = false } = {}) {
-  var _a;
-  if (ignoreWhitespace) {
-    if (node2.type.name === "hardBreak") {
-      return true;
-    }
-    if (node2.isText) {
-      return /^\s*$/m.test((_a = node2.text) !== null && _a !== void 0 ? _a : "");
-    }
-  }
-  if (node2.isText) {
-    return !node2.text;
-  }
-  if (node2.isAtom || node2.isLeaf) {
-    return false;
-  }
-  if (node2.content.childCount === 0) {
-    return true;
-  }
-  if (checkChildren) {
-    let isContentEmpty = true;
-    node2.content.forEach((childNode) => {
-      if (isContentEmpty === false) {
-        return;
-      }
-      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
-        isContentEmpty = false;
-      }
-    });
-    return isContentEmpty;
-  }
-  return false;
-}
-function canSetMark(state, tr, newMarkType) {
-  var _a;
-  const { selection } = tr;
-  let cursor = null;
-  if (isTextSelection(selection)) {
-    cursor = selection.$cursor;
-  }
-  if (cursor) {
-    const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
-    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType));
-  }
-  const { ranges } = selection;
-  return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
-    state.doc.nodesBetween($from.pos, $to.pos, (node2, _pos, parent) => {
-      if (someNodeSupportsMark) {
-        return false;
-      }
-      if (node2.isInline) {
-        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node2.marks) || !node2.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
-        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
-      }
-      return !someNodeSupportsMark;
-    });
-    return someNodeSupportsMark;
-  });
-}
-var setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  const type = getMarkType(typeOrName, state.schema);
-  if (dispatch) {
-    if (empty) {
-      const oldAttributes = getMarkAttributes(state, type);
-      tr.addStoredMark(type.create({
-        ...oldAttributes,
-        ...attributes
-      }));
-    } else {
-      ranges.forEach((range) => {
-        const from = range.$from.pos;
-        const to = range.$to.pos;
-        state.doc.nodesBetween(from, to, (node2, pos) => {
-          const trimmedFrom = Math.max(pos, from);
-          const trimmedTo = Math.min(pos + node2.nodeSize, to);
-          const someHasMark = node2.marks.find((mark) => mark.type === type);
-          if (someHasMark) {
-            node2.marks.forEach((mark) => {
-              if (type === mark.type) {
-                tr.addMark(trimmedFrom, trimmedTo, type.create({
-                  ...mark.attrs,
-                  ...attributes
-                }));
-              }
-            });
-          } else {
-            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
-          }
-        });
-      });
-    }
-  }
-  return canSetMark(state, tr, type);
-};
-var setMeta = (key, value) => ({ tr }) => {
-  tr.setMeta(key, value);
-  return true;
-};
-var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (!type.isTextblock) {
-    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-    return false;
-  }
-  return chain().command(({ commands: commands2 }) => {
-    const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
-    if (canSetBlock) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).command(({ state: updatedState }) => {
-    return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-  }).run();
-};
-var setNodeSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const from = minMax(position, 0, doc.content.size);
-    const selection = NodeSelection.create(doc, from);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var setTextSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-    const minPos = TextSelection.atStart(doc).from;
-    const maxPos = TextSelection.atEnd(doc).to;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return sinkListItem$1(type)(state, dispatch);
-};
-function ensureMarks(state, splittableMarks) {
-  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
-  if (marks) {
-    const filteredMarks = marks.filter((mark) => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-    state.tr.ensureMarks(filteredMarks);
-  }
-}
-var splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
-  const { selection, doc } = tr;
-  const { $from, $to } = selection;
-  const extensionAttributes = editor.extensionManager.attributes;
-  const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-  if (selection instanceof NodeSelection && selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
-      return false;
-    }
-    if (dispatch) {
-      if (keepMarks) {
-        ensureMarks(state, editor.extensionManager.splittableMarks);
-      }
-      tr.split($from.pos).scrollIntoView();
-    }
-    return true;
-  }
-  if (!$from.parent.isBlock) {
-    return false;
-  }
-  const atEnd = $to.parentOffset === $to.parent.content.size;
-  const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-  let types = atEnd && deflt ? [
-    {
-      type: deflt,
-      attrs: newAttributes
-    }
-  ] : void 0;
-  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-  if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-    can = true;
-    types = deflt ? [
-      {
-        type: deflt,
-        attrs: newAttributes
-      }
-    ] : void 0;
-  }
-  if (dispatch) {
-    if (can) {
-      if (selection instanceof TextSelection) {
-        tr.deleteSelection();
-      }
-      tr.split(tr.mapping.map($from.pos), 1, types);
-      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-        const first2 = tr.mapping.map($from.before());
-        const $first = tr.doc.resolve(first2);
-        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-        }
-      }
-    }
-    if (keepMarks) {
-      ensureMarks(state, editor.extensionManager.splittableMarks);
-    }
-    tr.scrollIntoView();
-  }
-  return can;
-};
-var splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-  var _a;
-  const type = getNodeType(typeOrName, state.schema);
-  const { $from, $to } = state.selection;
-  const node2 = state.selection.node;
-  if (node2 && node2.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-    return false;
-  }
-  const grandParent = $from.node(-1);
-  if (grandParent.type !== type) {
-    return false;
-  }
-  const extensionAttributes = editor.extensionManager.attributes;
-  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-    if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-      return false;
-    }
-    if (dispatch) {
-      let wrap = Fragment6.empty;
-      const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-        wrap = Fragment6.from($from.node(d).copy(wrap));
-      }
-      const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-      const newNextTypeAttributes2 = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-      wrap = wrap.append(Fragment6.from(type.createAndFill(null, nextType2) || void 0));
-      const start = $from.before($from.depth - (depthBefore - 1));
-      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
-      let sel = -1;
-      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-        if (sel > -1) {
-          return false;
-        }
-        if (n.isTextblock && n.content.size === 0) {
-          sel = pos + 1;
-        }
-      });
-      if (sel > -1) {
-        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
-      }
-      tr.scrollIntoView();
-    }
-    return true;
-  }
-  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-  const newTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-    ...overrideAttrs
-  };
-  const newNextTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-    ...overrideAttrs
-  };
-  tr.delete($from.pos, $to.pos);
-  const types = nextType ? [
-    { type, attrs: newTypeAttributes },
-    { type: nextType, attrs: newNextTypeAttributes }
-  ] : [{ type, attrs: newTypeAttributes }];
-  if (!canSplit(tr.doc, $from.pos, 2)) {
-    return false;
-  }
-  if (dispatch) {
-    const { selection, storedMarks } = state;
-    const { splittableMarks } = editor.extensionManager;
-    const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-    tr.split($from.pos, 2, types).scrollIntoView();
-    if (!marks || !dispatch) {
-      return true;
-    }
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-  }
-  return true;
-};
-var joinListBackwards = (tr, listType) => {
-  const list = findParentNode((node2) => node2.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-  if (before === void 0) {
-    return true;
-  }
-  const nodeBefore = tr.doc.nodeAt(before);
-  const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
-  if (!canJoinBackwards) {
-    return true;
-  }
-  tr.join(list.pos);
-  return true;
-};
-var joinListForwards = (tr, listType) => {
-  const list = findParentNode((node2) => node2.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const after = tr.doc.resolve(list.start).after(list.depth);
-  if (after === void 0) {
-    return true;
-  }
-  const nodeAfter = tr.doc.nodeAt(after);
-  const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
-  if (!canJoinForwards) {
-    return true;
-  }
-  tr.join(after);
-  return true;
-};
-var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands: commands2, can }) => {
-  const { extensions, splittableMarks } = editor.extensionManager;
-  const listType = getNodeType(listTypeOrName, state.schema);
-  const itemType = getNodeType(itemTypeOrName, state.schema);
-  const { selection, storedMarks } = state;
-  const { $from, $to } = selection;
-  const range = $from.blockRange($to);
-  const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-  if (!range) {
-    return false;
-  }
-  const parentList = findParentNode((node2) => isList(node2.type.name, extensions))(selection);
-  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-    if (parentList.node.type === listType) {
-      return commands2.liftListItem(itemType);
-    }
-    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
-      return chain().command(() => {
-        tr.setNodeMarkup(parentList.pos, listType);
-        return true;
-      }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-    }
-  }
-  if (!keepMarks || !marks || !dispatch) {
-    return chain().command(() => {
-      const canWrapInList = can().wrapInList(listType, attributes);
-      if (canWrapInList) {
-        return true;
-      }
-      return commands2.clearNodes();
-    }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-  }
-  return chain().command(() => {
-    const canWrapInList = can().wrapInList(listType, attributes);
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-    if (canWrapInList) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-};
-var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-  const { extendEmptyMarkRange = false } = options;
-  const type = getMarkType(typeOrName, state.schema);
-  const isActive = isMarkActive(state, type, attributes);
-  if (isActive) {
-    return commands2.unsetMark(type, { extendEmptyMarkRange });
-  }
-  return commands2.setMark(type, attributes);
-};
-var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const toggleType = getNodeType(toggleTypeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (isActive) {
-    return commands2.setNode(toggleType, attributesToCopy);
-  }
-  return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-};
-var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (isActive) {
-    return commands2.lift(type);
-  }
-  return commands2.wrapIn(type, attributes);
-};
-var undoInputRule = () => ({ state, dispatch }) => {
-  const plugins = state.plugins;
-  for (let i = 0; i < plugins.length; i += 1) {
-    const plugin = plugins[i];
-    let undoable;
-    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-      if (dispatch) {
-        const tr = state.tr;
-        const toUndo = undoable.transform;
-        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
-        }
-        if (undoable.text) {
-          const marks = tr.doc.resolve(undoable.from).marks();
-          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
-        } else {
-          tr.delete(undoable.from, undoable.to);
-        }
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var unsetAllMarks = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  if (empty) {
-    return true;
-  }
-  if (dispatch) {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos);
-    });
-  }
-  return true;
-};
-var unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-  var _a;
-  const { extendEmptyMarkRange = false } = options;
-  const { selection } = tr;
-  const type = getMarkType(typeOrName, state.schema);
-  const { $from, empty, ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  if (empty && extendEmptyMarkRange) {
-    let { from, to } = selection;
-    const attrs = (_a = $from.marks().find((mark) => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-    const range = getMarkRange($from, type, attrs);
-    if (range) {
-      from = range.from;
-      to = range.to;
-    }
-    tr.removeMark(from, to, type);
-  } else {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos, type);
-    });
-  }
-  tr.removeStoredMark(type);
-  return true;
-};
-var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      const from = range.$from.pos;
-      const to = range.$to.pos;
-      let lastPos;
-      let lastNode;
-      let trimmedFrom;
-      let trimmedTo;
-      if (tr.selection.empty) {
-        state.doc.nodesBetween(from, to, (node2, pos) => {
-          if (nodeType && nodeType === node2.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node2.nodeSize, to);
-            lastPos = pos;
-            lastNode = node2;
-          }
-        });
-      } else {
-        state.doc.nodesBetween(from, to, (node2, pos) => {
-          if (pos < from && nodeType && nodeType === node2.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node2.nodeSize, to);
-            lastPos = pos;
-            lastNode = node2;
-          }
-          if (pos >= from && pos <= to) {
-            if (nodeType && nodeType === node2.type) {
-              tr.setNodeMarkup(pos, void 0, {
-                ...node2.attrs,
-                ...attributes
-              });
-            }
-            if (markType && node2.marks.length) {
-              node2.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  const trimmedFrom2 = Math.max(pos, from);
-                  const trimmedTo2 = Math.min(pos + node2.nodeSize, to);
-                  tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  }));
-                }
-              });
-            }
-          }
-        });
-      }
-      if (lastNode) {
-        if (lastPos !== void 0) {
-          tr.setNodeMarkup(lastPos, void 0, {
-            ...lastNode.attrs,
-            ...attributes
-          });
-        }
-        if (markType && lastNode.marks.length) {
-          lastNode.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                ...mark.attrs,
-                ...attributes
-              }));
-            }
-          });
-        }
-      }
-    });
-  }
-  return true;
-};
-var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapIn$1(type, attributes)(state, dispatch);
-};
-var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapInList$1(type, attributes)(state, dispatch);
-};
-var commands = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  blur,
-  clearContent,
-  clearNodes,
-  command,
-  createParagraphNear,
-  cut,
-  deleteCurrentNode,
-  deleteNode,
-  deleteRange,
-  deleteSelection,
-  enter,
-  exitCode,
-  extendMarkRange,
-  first,
-  focus,
-  forEach,
-  insertContent,
-  insertContentAt,
-  joinBackward,
-  joinDown,
-  joinForward,
-  joinItemBackward,
-  joinItemForward,
-  joinTextblockBackward,
-  joinTextblockForward,
-  joinUp,
-  keyboardShortcut,
-  lift,
-  liftEmptyBlock,
-  liftListItem,
-  newlineInCode,
-  resetAttributes,
-  scrollIntoView,
-  selectAll,
-  selectNodeBackward,
-  selectNodeForward,
-  selectParentNode,
-  selectTextblockEnd,
-  selectTextblockStart,
-  setContent,
-  setMark,
-  setMeta,
-  setNode,
-  setNodeSelection,
-  setTextSelection,
-  sinkListItem,
-  splitBlock,
-  splitListItem,
-  toggleList,
-  toggleMark,
-  toggleNode,
-  toggleWrap,
-  undoInputRule,
-  unsetAllMarks,
-  unsetMark,
-  updateAttributes,
-  wrapIn,
-  wrapInList
-});
-var Commands = Extension.create({
-  name: "commands",
-  addCommands() {
-    return {
-      ...commands
-    };
-  }
-});
-var Drop = Extension.create({
-  name: "drop",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapDrop"),
-        props: {
-          handleDrop: (_2, e2, slice, moved) => {
-            this.editor.emit("drop", {
-              editor: this.editor,
-              event: e2,
-              slice,
-              moved
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Editable = Extension.create({
-  name: "editable",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("editable"),
-        props: {
-          editable: () => this.editor.options.editable
-        }
-      })
-    ];
-  }
-});
-var focusEventsPluginKey = new PluginKey("focusEvents");
-var FocusEvents = Extension.create({
-  name: "focusEvents",
-  addProseMirrorPlugins() {
-    const { editor } = this;
-    return [
-      new Plugin({
-        key: focusEventsPluginKey,
-        props: {
-          handleDOMEvents: {
-            focus: (view, event) => {
-              editor.isFocused = true;
-              const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            },
-            blur: (view, event) => {
-              editor.isFocused = false;
-              const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            }
-          }
-        }
-      })
-    ];
-  }
-});
-var Keymap = Extension.create({
-  name: "keymap",
-  addKeyboardShortcuts() {
-    const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.undoInputRule(),
-      // maybe convert first text block node to default node
-      () => commands2.command(({ tr }) => {
-        const { selection, doc } = tr;
-        const { empty, $anchor } = selection;
-        const { pos, parent } = $anchor;
-        const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-        const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-        const parentPos = $anchor.pos - $anchor.parentOffset;
-        const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : Selection.atStart(doc).from === pos;
-        if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-          return false;
-        }
-        return commands2.clearNodes();
-      }),
-      () => commands2.deleteSelection(),
-      () => commands2.joinBackward(),
-      () => commands2.selectNodeBackward()
-    ]);
-    const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.deleteSelection(),
-      () => commands2.deleteCurrentNode(),
-      () => commands2.joinForward(),
-      () => commands2.selectNodeForward()
-    ]);
-    const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.newlineInCode(),
-      () => commands2.createParagraphNear(),
-      () => commands2.liftEmptyBlock(),
-      () => commands2.splitBlock()
-    ]);
-    const baseKeymap = {
-      Enter: handleEnter,
-      "Mod-Enter": () => this.editor.commands.exitCode(),
-      Backspace: handleBackspace,
-      "Mod-Backspace": handleBackspace,
-      "Shift-Backspace": handleBackspace,
-      Delete: handleDelete,
-      "Mod-Delete": handleDelete,
-      "Mod-a": () => this.editor.commands.selectAll()
-    };
-    const pcKeymap = {
-      ...baseKeymap
-    };
-    const macKeymap = {
-      ...baseKeymap,
-      "Ctrl-h": handleBackspace,
-      "Alt-Backspace": handleBackspace,
-      "Ctrl-d": handleDelete,
-      "Ctrl-Alt-Backspace": handleDelete,
-      "Alt-Delete": handleDelete,
-      "Alt-d": handleDelete,
-      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-    };
-    if (isiOS() || isMacOS()) {
-      return macKeymap;
-    }
-    return pcKeymap;
-  },
-  addProseMirrorPlugins() {
-    return [
-      // With this plugin we check if the whole document was selected and deleted.
-      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-      // to a paragraph if necessary.
-      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-      // with many other commands.
-      new Plugin({
-        key: new PluginKey("clearDocument"),
-        appendTransaction: (transactions, oldState, newState) => {
-          if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-            return;
-          }
-          const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-          const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-          if (!docChanges || ignoreTr) {
-            return;
-          }
-          const { empty, from, to } = oldState.selection;
-          const allFrom = Selection.atStart(oldState.doc).from;
-          const allEnd = Selection.atEnd(oldState.doc).to;
-          const allWasSelected = from === allFrom && to === allEnd;
-          if (empty || !allWasSelected) {
-            return;
-          }
-          const isEmpty2 = isNodeEmpty(newState.doc);
-          if (!isEmpty2) {
-            return;
-          }
-          const tr = newState.tr;
-          const state = createChainableState({
-            state: newState,
-            transaction: tr
-          });
-          const { commands: commands2 } = new CommandManager({
-            editor: this.editor,
-            state
-          });
-          commands2.clearNodes();
-          if (!tr.steps.length) {
-            return;
-          }
-          return tr;
-        }
-      })
-    ];
-  }
-});
-var Paste = Extension.create({
-  name: "paste",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapPaste"),
-        props: {
-          handlePaste: (_view, e2, slice) => {
-            this.editor.emit("paste", {
-              editor: this.editor,
-              event: e2,
-              slice
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Tabindex = Extension.create({
-  name: "tabindex",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tabindex"),
-        props: {
-          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-        }
-      })
-    ];
-  }
-});
-function textblockTypeInputRule(config3) {
-  return new InputRule({
-    find: config3.find,
-    handler: ({ state, range, match }) => {
-      const $start = state.doc.resolve(range.from);
-      const attributes = callOrReturn(config3.getAttributes, void 0, match) || {};
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config3.type)) {
-        return null;
-      }
-      state.tr.delete(range.from, range.to).setBlockType(range.from, range.from, config3.type, attributes);
-    }
-  });
-}
-var Node2 = class _Node {
-  constructor(config3 = {}) {
-    this.type = "node";
-    this.name = "node";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config3
-    };
-    this.name = this.config.name;
-    if (config3.defaultOptions && Object.keys(config3.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config3 = {}) {
-    return new _Node(config3);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new _Node(extendedConfig);
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-};
-
 // src/scene/SceneBlockExtension.ts
-import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import { createRoot } from "react-dom/client";
 import { createElement as createElement6 } from "react";
@@ -13679,7 +11529,7 @@ function stripBraces(s) {
 }
 
 // src/scene/commands/layoutCommands.ts
-import { DOMSerializer as DOMSerializer2, DOMParser as PMDOMParser, Fragment as Fragment7 } from "@tiptap/pm/model";
+import { DOMSerializer, DOMParser as PMDOMParser, Fragment as Fragment6 } from "@tiptap/pm/model";
 import {
   parsePandocAttrTokens as parsePandocAttrTokens4,
   serializePandocAttributes as serializePandocAttributes4,
@@ -13821,7 +11671,7 @@ function addLayoutLayer(editor, parentPos, id, kind, params, bodyHtml = "") {
       dataTemplateParams: tParams.length > 0 ? tParams : null,
       dataBlockAttrs: blockAttrs
     });
-    let content = Fragment7.from(heading);
+    let content = Fragment6.from(heading);
     if (bodyHtml.trim()) content = content.append(htmlToBody(state.schema, bodyHtml));
     tr.insert(insertPos, content);
     return true;
@@ -13852,7 +11702,7 @@ function setLayoutText(editor, parentPos, id, bodyHtml) {
   const [, bodyEnd] = headingRange(editor, target.pos);
   return editor.chain().command(({ tr, state }) => {
     if (!tr.doc.nodeAt(target.pos)) return false;
-    const body = bodyHtml.trim() ? htmlToBody(state.schema, bodyHtml) : Fragment7.empty;
+    const body = bodyHtml.trim() ? htmlToBody(state.schema, bodyHtml) : Fragment6.empty;
     tr.replaceWith(bodyStart, bodyEnd, body);
     return true;
   }).run();
@@ -13899,7 +11749,7 @@ function bodyToHtml(editor, headingPos, headingNode) {
   if (bodyEnd <= bodyStart) return "";
   const fragment = state.doc.slice(bodyStart, bodyEnd).content;
   if (fragment.size === 0) return "";
-  const dom = DOMSerializer2.fromSchema(state.schema).serializeFragment(fragment);
+  const dom = DOMSerializer.fromSchema(state.schema).serializeFragment(fragment);
   const div = document.createElement("div");
   div.appendChild(dom);
   return div.innerHTML;
@@ -14807,7 +12657,7 @@ function createDrawShapeTool(options) {
 // src/scene/layers/DiagramEdges.tsx
 import { useId as useId8 } from "react";
 import { connectorPath, markerPath } from "@bendyline/squisq/doc";
-import { Fragment as Fragment8, jsx as jsx27, jsxs as jsxs21 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx27, jsxs as jsxs21 } from "react/jsx-runtime";
 var MARKER_STYLES = ["arrow", "open", "diamond", "circle", "square"];
 function markerId(prefix, style, dir) {
   return `${prefix}-squisq-edge-${style}-${dir}`;
@@ -14894,7 +12744,7 @@ function DiagramEdges({
                 children: edge2.label
               }
             ) : null,
-            selected ? /* @__PURE__ */ jsxs21(Fragment8, { children: [
+            selected ? /* @__PURE__ */ jsxs21(Fragment7, { children: [
               /* @__PURE__ */ jsx27("circle", { cx: start.x, cy: start.y, r: 6, className: "squisq-scene-edge-handle" }),
               /* @__PURE__ */ jsx27("circle", { cx: end.x, cy: end.y, r: 6, className: "squisq-scene-edge-handle" })
             ] }) : null
@@ -15915,7 +13765,7 @@ function findSceneHeadingPos(editor, headingKey, mode) {
   });
   return found;
 }
-var KEY = new PluginKey2("squisq-scene-block");
+var KEY = new PluginKey("squisq-scene-block");
 var TEMPLATE_MODE = {
   layout: "layout",
   drawing: "drawing"
@@ -15999,7 +13849,7 @@ var SceneBlockExtension = Extension.create({
     const enabled = this.options.enabled !== false;
     if (!enabled) return [];
     return [
-      new Plugin2({
+      new Plugin({
         key: KEY,
         state: {
           init: (_config, state) => buildDecorations(state, editor, this.options.textChannel),
@@ -16595,7 +14445,7 @@ function AddBin({ activeToolId, onActivate, canAddMedia, onAddMediaFiles }) {
 
 // src/customTemplates/LayerToolbar.tsx
 import { AVAILABLE_FONT_STACKS as AVAILABLE_FONT_STACKS2 } from "@bendyline/squisq/schemas";
-import { Fragment as Fragment9, jsx as jsx35, jsxs as jsxs26 } from "react/jsx-runtime";
+import { Fragment as Fragment8, jsx as jsx35, jsxs as jsxs26 } from "react/jsx-runtime";
 function LayerToolbar({ layer, onAttr }) {
   return /* @__PURE__ */ jsxs26("div", { className: "squisq-layer-toolbar", role: "toolbar", "aria-label": "Layer styling", children: [
     layer.type === "text" && /* @__PURE__ */ jsx35(TextControls, { layer, onAttr }),
@@ -16615,7 +14465,7 @@ function TextControls({
   onAttr
 }) {
   const style = layer.content.style;
-  return /* @__PURE__ */ jsxs26(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment8, { children: [
     /* @__PURE__ */ jsx35(
       SegGroup,
       {
@@ -16736,7 +14586,7 @@ function FillBorderControls({
   content,
   onAttr
 }) {
-  return /* @__PURE__ */ jsxs26(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment8, { children: [
     /* @__PURE__ */ jsx35("span", { className: "squisq-layer-toolbar-label", title: "Fill", children: /* @__PURE__ */ jsx35(Icon, { icon: "fa-solid fa-fill-drip" }) }),
     /* @__PURE__ */ jsx35(
       FillEditor,
@@ -16775,7 +14625,7 @@ function ShapeControls({
   layer,
   onAttr
 }) {
-  return /* @__PURE__ */ jsxs26(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment8, { children: [
     /* @__PURE__ */ jsxs26(
       "select",
       {
@@ -16893,7 +14743,7 @@ function FillEditor({
 }) {
   const isGradient = !!gradient;
   const swatch = color && color !== "none" ? color : defaultColor;
-  return /* @__PURE__ */ jsxs26(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment8, { children: [
     /* @__PURE__ */ jsxs26(
       "select",
       {
@@ -16914,7 +14764,7 @@ function FillEditor({
         ]
       }
     ),
-    isGradient ? /* @__PURE__ */ jsxs26(Fragment9, { children: [
+    isGradient ? /* @__PURE__ */ jsxs26(Fragment8, { children: [
       /* @__PURE__ */ jsx35(
         Color,
         {
@@ -16974,7 +14824,7 @@ function BorderEditor({
   stylePath,
   onAttr
 }) {
-  return /* @__PURE__ */ jsxs26(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs26(Fragment8, { children: [
     /* @__PURE__ */ jsx35(
       Color,
       {
@@ -17048,7 +14898,7 @@ function normalizeColor(v2) {
 }
 
 // src/customTemplates/TemplateDesigner.tsx
-import { Fragment as Fragment10, jsx as jsx36, jsxs as jsxs27 } from "react/jsx-runtime";
+import { Fragment as Fragment9, jsx as jsx36, jsxs as jsxs27 } from "react/jsx-runtime";
 var DESIGN_CANVAS = { width: 1920, height: 1080 };
 function slugifyLabel(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^[^a-z]+/, "").replace(/^-+|-+$/g, "");
@@ -17271,7 +15121,7 @@ function TemplateDesigner({
                   children: VIEWPORT_OPTIONS.map((v2) => /* @__PURE__ */ jsx36("option", { value: v2.id, children: v2.label }, v2.id))
                 }
               ),
-              selectedLayer && /* @__PURE__ */ jsxs27(Fragment10, { children: [
+              selectedLayer && /* @__PURE__ */ jsxs27(Fragment9, { children: [
                 /* @__PURE__ */ jsx36("div", { className: "squisq-layer-toolbar-sep", "aria-hidden": "true" }),
                 /* @__PURE__ */ jsx36(LayerToolbar, { layer: selectedLayer, onAttr: handleLayerAttr })
               ] })
@@ -17339,7 +15189,7 @@ function TemplateDesigner({
 }
 
 // src/customTemplates/CustomLayoutManager.tsx
-import { Fragment as Fragment11, jsx as jsx37, jsxs as jsxs28 } from "react/jsx-runtime";
+import { Fragment as Fragment10, jsx as jsx37, jsxs as jsxs28 } from "react/jsx-runtime";
 function CustomLayoutManager({ onClose }) {
   const { docTemplates, onDocTemplatesChange } = useDocCustomTemplates();
   const { mediaProvider, colorScheme } = useEditorContext();
@@ -17452,11 +15302,11 @@ function ManagerContent({
           children: "+ New layout"
         }
       ),
-      docTemplates.length > 0 && /* @__PURE__ */ jsxs28(Fragment11, { children: [
+      docTemplates.length > 0 && /* @__PURE__ */ jsxs28(Fragment10, { children: [
         /* @__PURE__ */ jsx37("div", { className: "squisq-layout-manager-section-title", children: "This document" }),
         /* @__PURE__ */ jsx37("div", { className: "squisq-layout-manager-list", children: docTemplates.map((def) => renderItem(def, "doc")) })
       ] }),
-      libraryTemplates.length > 0 && /* @__PURE__ */ jsxs28(Fragment11, { children: [
+      libraryTemplates.length > 0 && /* @__PURE__ */ jsxs28(Fragment10, { children: [
         /* @__PURE__ */ jsx37("div", { className: "squisq-layout-manager-section-title", children: "Library" }),
         /* @__PURE__ */ jsx37("div", { className: "squisq-layout-manager-list", children: libraryTemplates.map((def) => renderItem(def, "library")) })
       ] }),
@@ -17604,7 +15454,8 @@ function selectionToTaskListMarkdown(text) {
 import { useCallback as useCallback28, useEffect as useEffect23, useId as useId11, useRef as useRef27, useState as useState30 } from "react";
 
 // src/find/FindHighlightExtension.ts
-import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@tiptap/pm/state";
+import { Extension as Extension2 } from "@tiptap/core";
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@tiptap/pm/state";
 import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
 
 // src/find/findModel.ts
@@ -17659,7 +15510,7 @@ function escapeRegExp(value) {
 }
 
 // src/find/FindHighlightExtension.ts
-var FIND_HIGHLIGHT_KEY = new PluginKey3("squisq-find-highlight");
+var FIND_HIGHLIGHT_KEY = new PluginKey2("squisq-find-highlight");
 function buildState(doc, query, selectedIndex) {
   const matches = findProseMirrorMatches(doc, query);
   const selected = normalizeFindIndex(selectedIndex, matches.length);
@@ -17674,11 +15525,11 @@ function buildState(doc, query, selectedIndex) {
     decorations: DecorationSet2.create(doc, decorations)
   };
 }
-var FindHighlightExtension = Extension.create({
+var FindHighlightExtension = Extension2.create({
   name: "squisqFindHighlight",
   addProseMirrorPlugins() {
     return [
-      new Plugin3({
+      new Plugin2({
         key: FIND_HIGHLIGHT_KEY,
         state: {
           init: (_2, state) => buildState(state.doc, "", 0),
@@ -18237,8 +16088,8 @@ function isTiptapActive(editor, id) {
 }
 
 // src/toolbar/sceneBlockInserts.ts
-import { Fragment as Fragment12 } from "@tiptap/pm/model";
-import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+import { Fragment as Fragment11 } from "@tiptap/pm/model";
+import { TextSelection } from "@tiptap/pm/state";
 
 // src/codeSnippet/codeSnippetFocus.ts
 var CODE_SNIPPET_FOCUS_INSERTED_META = "squisq-code-snippet-focus-inserted";
@@ -18321,18 +16172,18 @@ function insertChartBlock(editor, opts) {
       const cell = (type, text) => type.create(null, paragraph.create(null, text ? state.schema.text(text) : void 0));
       const headerRow = tableRow.create(
         null,
-        Fragment12.fromArray(opts.table.headers.map((h2) => cell(tableHeader, h2)))
+        Fragment11.fromArray(opts.table.headers.map((h2) => cell(tableHeader, h2)))
       );
       const bodyRows = opts.table.rows.map(
-        (row) => tableRow.create(null, Fragment12.fromArray(row.map((c) => cell(tableCell, c))))
+        (row) => tableRow.create(null, Fragment11.fromArray(row.map((c) => cell(tableCell, c))))
       );
-      nodes.push(table.create(null, Fragment12.fromArray([headerRow, ...bodyRows])));
+      nodes.push(table.create(null, Fragment11.fromArray([headerRow, ...bodyRows])));
     }
     const { $from } = state.selection;
     const insertPos = $from.depth > 0 ? $from.after(1) : state.doc.content.size;
     if (dispatch) {
-      tr.insert(insertPos, Fragment12.fromArray(nodes));
-      tr.setSelection(TextSelection2.create(tr.doc, insertPos + 1));
+      tr.insert(insertPos, Fragment11.fromArray(nodes));
+      tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
     }
     return true;
   }).run();
@@ -18353,7 +16204,7 @@ function insertTemplateHeading(editor, opts) {
     const insertPos = $from.depth > 0 ? $from.after(1) : state.doc.content.size;
     if (dispatch) {
       tr.insert(insertPos, heading);
-      tr.setSelection(TextSelection2.create(tr.doc, insertPos + 1));
+      tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
     }
     return true;
   }).run();
@@ -18377,8 +16228,8 @@ function insertLayoutBlock(editor) {
     const { $from } = state.selection;
     const insertPos = $from.depth > 0 ? $from.after(1) : state.doc.content.size;
     if (dispatch) {
-      tr.insert(insertPos, Fragment12.fromArray([parent, child, body]));
-      tr.setSelection(TextSelection2.create(tr.doc, insertPos + 1));
+      tr.insert(insertPos, Fragment11.fromArray([parent, child, body]));
+      tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
     }
     return true;
   }).run();
@@ -18495,13 +16346,13 @@ ${chartTableMarkdown(entry.table)}
 }
 
 // src/chart/ChartTypeThumbnail.tsx
-import { Fragment as Fragment13, jsx as jsx40, jsxs as jsxs30 } from "react/jsx-runtime";
+import { Fragment as Fragment12, jsx as jsx40, jsxs as jsxs30 } from "react/jsx-runtime";
 function ChartTypeThumbnail({ preview }) {
   const common = { fill: "none", stroke: "currentColor", strokeWidth: 2 };
   let art;
   switch (preview) {
     case "bar":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("path", { d: "M14 8v48" }),
         /* @__PURE__ */ jsx40("rect", { x: "14", y: "12", width: "80", height: "9", fill: "currentColor", opacity: ".55" }),
         /* @__PURE__ */ jsx40("rect", { x: "14", y: "27", width: "52", height: "9", fill: "currentColor", opacity: ".35" }),
@@ -18509,7 +16360,7 @@ function ChartTypeThumbnail({ preview }) {
       ] });
       break;
     case "column":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("path", { d: "M10 54h100" }),
         /* @__PURE__ */ jsx40("rect", { x: "22", y: "26", width: "14", height: "28", fill: "currentColor", opacity: ".45" }),
         /* @__PURE__ */ jsx40("rect", { x: "44", y: "14", width: "14", height: "40", fill: "currentColor", opacity: ".55" }),
@@ -18518,14 +16369,14 @@ function ChartTypeThumbnail({ preview }) {
       ] });
       break;
     case "pie":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("circle", { cx: "60", cy: "32", r: "24" }),
         /* @__PURE__ */ jsx40("path", { d: "M60 32V8a24 24 0 0 1 22.6 31.9Z", fill: "currentColor", opacity: ".45" }),
         /* @__PURE__ */ jsx40("path", { d: "M60 32 82.6 39.9A24 24 0 0 1 46 53.4Z", fill: "currentColor", opacity: ".25" })
       ] });
       break;
     case "donut":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("circle", { cx: "60", cy: "32", r: "24" }),
         /* @__PURE__ */ jsx40("circle", { cx: "60", cy: "32", r: "11" }),
         /* @__PURE__ */ jsx40(
@@ -18539,7 +16390,7 @@ function ChartTypeThumbnail({ preview }) {
       ] });
       break;
     case "line":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("path", { d: "M10 54h100M10 8v46", opacity: ".4" }),
         /* @__PURE__ */ jsx40("path", { d: "M16 46l24-16 24 8 24-20 20 6", strokeWidth: "3" }),
         /* @__PURE__ */ jsx40("circle", { cx: "40", cy: "30", r: "3", fill: "currentColor" }),
@@ -18548,7 +16399,7 @@ function ChartTypeThumbnail({ preview }) {
       ] });
       break;
     case "area":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("path", { d: "M10 54h100", opacity: ".4" }),
         /* @__PURE__ */ jsx40(
           "path",
@@ -18563,7 +16414,7 @@ function ChartTypeThumbnail({ preview }) {
       ] });
       break;
     case "scatter":
-      art = /* @__PURE__ */ jsxs30(Fragment13, { children: [
+      art = /* @__PURE__ */ jsxs30(Fragment12, { children: [
         /* @__PURE__ */ jsx40("path", { d: "M14 8v46h92", opacity: ".4" }),
         /* @__PURE__ */ jsx40("circle", { cx: "30", cy: "42", r: "3.5", fill: "currentColor", opacity: ".5" }),
         /* @__PURE__ */ jsx40("circle", { cx: "42", cy: "30", r: "3.5", fill: "currentColor" }),
@@ -18578,7 +16429,7 @@ function ChartTypeThumbnail({ preview }) {
 }
 
 // src/Toolbar.tsx
-import { Fragment as Fragment14, jsx as jsx41, jsxs as jsxs31 } from "react/jsx-runtime";
+import { Fragment as Fragment13, jsx as jsx41, jsxs as jsxs31 } from "react/jsx-runtime";
 var VIEWS = [
   { id: "wysiwyg", label: "Write", shortcutKey: "1" },
   { id: "raw", label: "Source", shortcutKey: "2" },
@@ -20249,7 +18100,7 @@ ${TASK_LIST_MARKDOWN}
                     ]
                   }
                 ),
-                showBlockSectionInOverflow && /* @__PURE__ */ jsxs31(Fragment14, { children: [
+                showBlockSectionInOverflow && /* @__PURE__ */ jsxs31(Fragment13, { children: [
                   /* @__PURE__ */ jsx41(
                     "div",
                     {
@@ -20284,7 +18135,7 @@ ${TASK_LIST_MARKDOWN}
                     accentColor: previewSettings?.activeTheme.colors.primary
                   }
                 ) }),
-                isInTable && clippedContextual.has("table") && /* @__PURE__ */ jsxs31(Fragment14, { children: [
+                isInTable && clippedContextual.has("table") && /* @__PURE__ */ jsxs31(Fragment13, { children: [
                   /* @__PURE__ */ jsx41(
                     "div",
                     {
@@ -20415,7 +18266,7 @@ ${TASK_LIST_MARKDOWN}
               style: { position: "fixed", top: insertMenuAnchor.top, left: insertMenuAnchor.left },
               role: "menu",
               children: [
-                showConvertActions && /* @__PURE__ */ jsxs31(Fragment14, { children: [
+                showConvertActions && /* @__PURE__ */ jsxs31(Fragment13, { children: [
                   /* @__PURE__ */ jsx41("div", { className: "squisq-insert-menu-header", children: "Convert" }),
                   CONVERT_BUTTONS.map((btn) => {
                     const label = btn.id === "table" ? "Table" : "Task List";
@@ -21396,75 +19247,8 @@ function formatClock(raw) {
   return `${minutes}:${String(secs).padStart(2, "0")}`;
 }
 
-// ../../node_modules/@tiptap/extension-heading/dist/index.js
-var Heading = Node2.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
-      }
-    };
-  },
-  parseHTML() {
-    return this.options.levels.map((level) => ({
-      tag: `h${level}`,
-      attrs: { level }
-    }));
-  },
-  renderHTML({ node: node2, HTMLAttributes }) {
-    const hasLevel = this.options.levels.includes(node2.attrs.level);
-    const level = hasLevel ? node2.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;
-        }
-        return commands2.setNode(this.name, attributes);
-      },
-      toggleHeading: (attributes) => ({ commands: commands2 }) => {
-        if (!this.options.levels.includes(attributes.level)) {
-          return false;
-        }
-        return commands2.toggleNode(this.name, "paragraph", attributes);
-      }
-    };
-  },
-  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(`^(#{${Math.min(...this.options.levels)},${level}})\\s$`),
-        type: this.type,
-        getAttributes: {
-          level
-        }
-      });
-    });
-  }
-});
-
 // src/TemplateAnnotation.ts
+import Heading from "@tiptap/extension-heading";
 var HeadingWithTemplate = Heading.extend({
   addAttributes() {
     return {
@@ -21902,7 +19686,8 @@ import {
 } from "@bendyline/squisq/doc";
 
 // src/asciiDiagram/AsciiDiagramExtension.ts
-import { Plugin as Plugin5, PluginKey as PluginKey5 } from "@tiptap/pm/state";
+import { Extension as Extension4 } from "@tiptap/core";
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "@tiptap/pm/state";
 import { Decoration as Decoration4, DecorationSet as DecorationSet4 } from "@tiptap/pm/view";
 import { createRoot as createRoot2 } from "react-dom/client";
 import { createElement as createElement8 } from "react";
@@ -21927,7 +19712,8 @@ import {
 } from "@bendyline/squisq/doc";
 
 // src/asciiDiagram/RepairableDiagramExtension.ts
-import { Plugin as Plugin4, PluginKey as PluginKey4 } from "@tiptap/pm/state";
+import { Extension as Extension3 } from "@tiptap/core";
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@tiptap/pm/state";
 import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "@tiptap/pm/view";
 import { isEligibleAsciiFenceLang, isRepairableDiagram } from "@bendyline/squisq/doc";
 
@@ -21960,7 +19746,7 @@ function mapFenceEntries(tr, previous, doc) {
 }
 
 // src/asciiDiagram/RepairableDiagramExtension.ts
-var REPAIRABLE_KEY = new PluginKey4("squisq-repairable-diagram");
+var REPAIRABLE_KEY = new PluginKey3("squisq-repairable-diagram");
 var cache = /* @__PURE__ */ new WeakMap();
 function fenceLangOf(node2) {
   const lang = node2.attrs.language;
@@ -22028,7 +19814,7 @@ function applyState(tr, prev, editor, doc, onRepair) {
   });
   return { entries, seq, decorations: buildDecorations2(doc, entries, editor, onRepair) };
 }
-var RepairableDiagramExtension = Extension.create({
+var RepairableDiagramExtension = Extension3.create({
   name: "squisqRepairableDiagram",
   addOptions() {
     return { enabled: true };
@@ -22038,7 +19824,7 @@ var RepairableDiagramExtension = Extension.create({
     if (this.options.enabled === false) return [];
     const onRepair = this.options.onRepair;
     return [
-      new Plugin4({
+      new Plugin3({
         key: REPAIRABLE_KEY,
         state: {
           init: (_config, state) => {
@@ -22351,7 +20137,7 @@ function containFenceWidgetEvents(container) {
 }
 
 // src/asciiDiagram/AsciiDiagramExtension.ts
-var ASCII_DIAGRAM_KEY = new PluginKey5("squisq-ascii-diagram");
+var ASCII_DIAGRAM_KEY = new PluginKey4("squisq-ascii-diagram");
 var detectCache = /* @__PURE__ */ new WeakMap();
 var parseCache = /* @__PURE__ */ new WeakMap();
 function fenceLangOf2(node2) {
@@ -22486,7 +20272,7 @@ function applyState2(tr, prev, editor, doc, textChannel) {
     decorations: buildDecorations3(doc, entries, prunedSourceVisible, editor, textChannel)
   };
 }
-var AsciiDiagramExtension = Extension.create({
+var AsciiDiagramExtension = Extension4.create({
   name: "squisqAsciiDiagram",
   addOptions() {
     return {
@@ -22497,7 +20283,7 @@ var AsciiDiagramExtension = Extension.create({
     const editor = this.editor;
     if (this.options.enabled === false) return [];
     return [
-      new Plugin5({
+      new Plugin4({
         key: ASCII_DIAGRAM_KEY,
         state: {
           init: (_config, state) => {
@@ -23692,14 +21478,14 @@ function addAdapterNode(source, model2) {
       result = appendStatement(source, "    New task: 3: User");
       break;
     case "kanban": {
-      const first2 = model2.nodes[0];
-      if (!first2) {
+      const first = model2.nodes[0];
+      if (!first) {
         result = appendStatement(source, `  todo[To do]
     ${id}[New task]`);
       } else {
-        const line = sourceLine(first2) ?? 1;
+        const line = sourceLine(first) ?? 1;
         const lines2 = linesOf(source);
-        lines2.splice(line, 0, `${String(first2.origin?.indent ?? "    ")}${id}[New task]`);
+        lines2.splice(line, 0, `${String(first.origin?.indent ?? "    ")}${id}[New task]`);
         result = sourceResult(source, lines2);
       }
       break;
@@ -25386,7 +23172,8 @@ function MermaidShapeThumb({ shape }) {
 import { useEffect as useEffect30, useMemo as useMemo30, useState as useState39 } from "react";
 
 // src/mermaid/MermaidDiagramExtension.ts
-import { Plugin as Plugin6, PluginKey as PluginKey6 } from "@tiptap/pm/state";
+import { Extension as Extension5 } from "@tiptap/core";
+import { Plugin as Plugin5, PluginKey as PluginKey5 } from "@tiptap/pm/state";
 import { Decoration as Decoration5, DecorationSet as DecorationSet5 } from "@tiptap/pm/view";
 import { createElement as createElement9 } from "react";
 import { createRoot as createRoot3 } from "react-dom/client";
@@ -25733,7 +23520,7 @@ function setMermaidFlowchartDirection(source, direction) {
 
 // src/mermaid/MermaidDiagramWidget.tsx
 import { DEFAULT_THEME as DEFAULT_THEME3 } from "@bendyline/squisq/doc";
-import { Fragment as Fragment15, jsx as jsx48, jsxs as jsxs37 } from "react/jsx-runtime";
+import { Fragment as Fragment14, jsx as jsx48, jsxs as jsxs37 } from "react/jsx-runtime";
 var MIN_DIAGRAM_HEIGHT2 = 160;
 var DEFAULT_DIAGRAM_HEIGHT2 = 420;
 var DIRECTION_PICKER_WIDTH = 344;
@@ -26394,7 +24181,7 @@ function MermaidPropertiesPalette({
             }
           ),
           /* @__PURE__ */ jsx48("span", { children: property.label })
-        ] }) : /* @__PURE__ */ jsxs37(Fragment15, { children: [
+        ] }) : /* @__PURE__ */ jsxs37(Fragment14, { children: [
           /* @__PURE__ */ jsx48("span", { children: property.label }),
           property.type === "select" ? /* @__PURE__ */ jsx48(
             "select",
@@ -26485,22 +24272,22 @@ function MermaidDirectionThumbnail({
 }) {
   const horizontal = direction === "LR" || direction === "RL";
   const reversed = direction === "RL" || direction === "BT";
-  const first2 = horizontal ? { x: reversed ? 79 : 7, y: 21 } : { x: 43, y: reversed ? 39 : 3 };
+  const first = horizontal ? { x: reversed ? 79 : 7, y: 21 } : { x: 43, y: reversed ? 39 : 3 };
   const second = horizontal ? { x: reversed ? 7 : 79, y: 21 } : { x: 43, y: reversed ? 3 : 39 };
   const path = direction === "LR" ? "M41 32H75" : direction === "RL" ? "M79 32H45" : direction === "TB" ? "M60 25V35" : "M60 39V29";
   const arrow = direction === "LR" ? "75,32 68,28 68,36" : direction === "RL" ? "45,32 52,28 52,36" : direction === "TB" ? "60,35 56,28 64,28" : "60,29 56,36 64,36";
   return /* @__PURE__ */ jsxs37("svg", { viewBox: "0 0 120 64", "aria-hidden": "true", children: [
-    /* @__PURE__ */ jsx48("rect", { x: first2.x, y: first2.y, width: "34", height: "22", rx: "3" }),
+    /* @__PURE__ */ jsx48("rect", { x: first.x, y: first.y, width: "34", height: "22", rx: "3" }),
     /* @__PURE__ */ jsx48("rect", { x: second.x, y: second.y, width: "34", height: "22", rx: "3" }),
     /* @__PURE__ */ jsx48("path", { d: path }),
     /* @__PURE__ */ jsx48("polygon", { points: arrow }),
-    /* @__PURE__ */ jsx48("text", { x: first2.x + 17, y: first2.y + 14, children: "A" }),
+    /* @__PURE__ */ jsx48("text", { x: first.x + 17, y: first.y + 14, children: "A" }),
     /* @__PURE__ */ jsx48("text", { x: second.x + 17, y: second.y + 14, children: "B" })
   ] });
 }
 
 // src/mermaid/MermaidDiagramExtension.ts
-var MERMAID_DIAGRAM_KEY = new PluginKey6(
+var MERMAID_DIAGRAM_KEY = new PluginKey5(
   "squisq-mermaid-diagram"
 );
 function fenceLanguage(node2) {
@@ -26604,7 +24391,7 @@ function applyState3(tr, previous, editor, doc, themeStore) {
     decorations: buildDecorations4(doc, entries, prunedSourceVisible, editor, themeStore)
   };
 }
-var MermaidDiagramExtension = Extension.create({
+var MermaidDiagramExtension = Extension5.create({
   name: "squisqMermaidDiagram",
   addOptions() {
     return { enabled: true };
@@ -26614,7 +24401,7 @@ var MermaidDiagramExtension = Extension.create({
     const editor = this.editor;
     const themeStore = this.options.themeStore;
     return [
-      new Plugin6({
+      new Plugin5({
         key: MERMAID_DIAGRAM_KEY,
         state: {
           init: (_config, state) => {
@@ -26666,7 +24453,8 @@ function useMermaidDiagramData(editor, blockId) {
 }
 
 // src/codeSnippet/CodeSnippetExtension.ts
-import { Plugin as Plugin7, PluginKey as PluginKey7 } from "@tiptap/pm/state";
+import { Extension as Extension6 } from "@tiptap/core";
+import { Plugin as Plugin6, PluginKey as PluginKey6 } from "@tiptap/pm/state";
 import { Decoration as Decoration6, DecorationSet as DecorationSet6 } from "@tiptap/pm/view";
 import { createElement as createElement10 } from "react";
 import { createRoot as createRoot4 } from "react-dom/client";
@@ -26819,7 +24607,7 @@ function CodeSnippetWidget({
 }
 
 // src/codeSnippet/CodeSnippetExtension.ts
-var CODE_SNIPPET_KEY = new PluginKey7("squisq-code-snippet");
+var CODE_SNIPPET_KEY = new PluginKey6("squisq-code-snippet");
 function isCodeSnippetNode(node2) {
   const language = node2.attrs.language;
   return node2.type.name === "codeBlock" && isCodeSnippetFenceLanguage(typeof language === "string" ? language : null);
@@ -26915,7 +24703,7 @@ function applyState4(tr, previous, editor, doc) {
     decorations: buildDecorations5(doc, entries, editor, focusBlockId)
   };
 }
-var CodeSnippetExtension = Extension.create({
+var CodeSnippetExtension = Extension6.create({
   name: "squisqCodeSnippet",
   addOptions() {
     return { enabled: true };
@@ -26924,7 +24712,7 @@ var CodeSnippetExtension = Extension.create({
     if (this.options.enabled === false) return [];
     const editor = this.editor;
     return [
-      new Plugin7({
+      new Plugin6({
         key: CODE_SNIPPET_KEY,
         state: {
           init: (_config, state) => {
@@ -26973,7 +24761,8 @@ function replaceCodeSnippetText(editor, blockId, nextText) {
 import { useEffect as useEffect33, useMemo as useMemo32, useState as useState43 } from "react";
 
 // src/treeview/TreeViewExtension.ts
-import { Plugin as Plugin8, PluginKey as PluginKey8 } from "@tiptap/pm/state";
+import { Extension as Extension7 } from "@tiptap/core";
+import { Plugin as Plugin7, PluginKey as PluginKey7 } from "@tiptap/pm/state";
 import { Decoration as Decoration7, DecorationSet as DecorationSet7 } from "@tiptap/pm/view";
 import { createRoot as createRoot5 } from "react-dom/client";
 import { createElement as createElement11 } from "react";
@@ -27529,7 +25318,7 @@ function TreeRowView({
 }
 
 // src/treeview/TreeViewExtension.ts
-var TREEVIEW_KEY = new PluginKey8("squisq-treeview");
+var TREEVIEW_KEY = new PluginKey7("squisq-treeview");
 var detectCache2 = /* @__PURE__ */ new WeakMap();
 var parseCache2 = /* @__PURE__ */ new WeakMap();
 function fenceLangOf3(node2) {
@@ -27636,7 +25425,7 @@ function applyState5(tr, prev, editor, doc) {
   });
   return { entries, seq, decorations: buildDecorations6(doc, entries, editor) };
 }
-var TreeViewExtension = Extension.create({
+var TreeViewExtension = Extension7.create({
   name: "squisqTreeView",
   addOptions() {
     return { enabled: true };
@@ -27645,7 +25434,7 @@ var TreeViewExtension = Extension.create({
     const editor = this.editor;
     if (this.options.enabled === false) return [];
     return [
-      new Plugin8({
+      new Plugin7({
         key: TREEVIEW_KEY,
         state: {
           init: (_config, state) => {
@@ -27707,7 +25496,8 @@ function shouldPasteAsTreeFence(text) {
 import { useEffect as useEffect35, useMemo as useMemo34, useRef as useRef37, useState as useState45 } from "react";
 
 // src/timeline/TimelineViewExtension.ts
-import { Plugin as Plugin9, PluginKey as PluginKey9 } from "@tiptap/pm/state";
+import { Extension as Extension8 } from "@tiptap/core";
+import { Plugin as Plugin8, PluginKey as PluginKey8 } from "@tiptap/pm/state";
 import { Decoration as Decoration8, DecorationSet as DecorationSet8 } from "@tiptap/pm/view";
 import { createElement as createElement12 } from "react";
 import { createRoot as createRoot6 } from "react-dom/client";
@@ -28128,30 +25918,30 @@ function applyOp3(editor, blockId, op, verifyResult) {
     ...result.trackId ? { trackId: result.trackId } : {}
   };
 }
-function applyTimelineCommand(editor, blockId, command2) {
+function applyTimelineCommand(editor, blockId, command) {
   if (!editor.isEditable) return READ_ONLY;
-  switch (command2.kind) {
+  switch (command.kind) {
     case "addTrack":
       return applyOp3(
         editor,
         blockId,
         (timeline) => addTimelineTrackOp(timeline, {
-          id: command2.id,
-          label: command2.label,
-          eventId: command2.eventId,
-          eventLabel: command2.eventLabel
+          id: command.id,
+          label: command.label,
+          eventId: command.eventId,
+          eventLabel: command.eventLabel
         })
       );
     case "updateTrack": {
-      const expectedLabel = sanitizeTimelineText(command2.label);
+      const expectedLabel = sanitizeTimelineText(command.label);
       return applyOp3(
         editor,
         blockId,
         (timeline) => ({
-          timeline: updateTimelineTrackOp(timeline, command2.trackId, command2.label)
+          timeline: updateTimelineTrackOp(timeline, command.trackId, command.label)
         }),
         (timeline) => timeline.tracks.some(
-          (track) => track.id === command2.trackId && track.label === expectedLabel
+          (track) => track.id === command.trackId && track.label === expectedLabel
         )
       );
     }
@@ -28159,19 +25949,19 @@ function applyTimelineCommand(editor, blockId, command2) {
       return applyOp3(
         editor,
         blockId,
-        (timeline) => ({ timeline: removeTimelineTrackOp(timeline, command2.trackId) }),
-        (timeline) => !hasTrack(timeline, command2.trackId)
+        (timeline) => ({ timeline: removeTimelineTrackOp(timeline, command.trackId) }),
+        (timeline) => !hasTrack(timeline, command.trackId)
       );
     case "addEvent":
       return applyOp3(editor, blockId, (timeline) => {
-        const result = addTimelineEventOp(timeline, command2.trackId, command2.position, {
-          id: command2.id,
-          label: command2.label,
-          description: command2.description,
-          side: command2.side,
-          descriptionSide: command2.descriptionSide,
-          callout: command2.callout,
-          marker: command2.marker
+        const result = addTimelineEventOp(timeline, command.trackId, command.position, {
+          id: command.id,
+          label: command.label,
+          description: command.description,
+          side: command.side,
+          descriptionSide: command.descriptionSide,
+          callout: command.callout,
+          marker: command.marker
         });
         return result;
       });
@@ -28180,25 +25970,25 @@ function applyTimelineCommand(editor, blockId, command2) {
         editor,
         blockId,
         (timeline) => ({
-          timeline: updateTimelineEventOp(timeline, command2.eventId, command2.patch)
+          timeline: updateTimelineEventOp(timeline, command.eventId, command.patch)
         }),
-        (timeline) => hasEvent(timeline, command2.eventId)
+        (timeline) => hasEvent(timeline, command.eventId)
       );
     case "removeEvent":
       return applyOp3(
         editor,
         blockId,
-        (timeline) => ({ timeline: removeTimelineEventOp(timeline, command2.eventId) }),
-        (timeline) => !hasEvent(timeline, command2.eventId)
+        (timeline) => ({ timeline: removeTimelineEventOp(timeline, command.eventId) }),
+        (timeline) => !hasEvent(timeline, command.eventId)
       );
   }
-  const exhaustive = command2;
+  const exhaustive = command;
   void exhaustive;
   return NOT_APPLIED;
 }
 
 // src/timeline/TimelineEditorWidget.tsx
-import { Fragment as Fragment16, jsx as jsx51, jsxs as jsxs40 } from "react/jsx-runtime";
+import { Fragment as Fragment15, jsx as jsx51, jsxs as jsxs40 } from "react/jsx-runtime";
 var clamp01 = (value) => Math.max(0, Math.min(1, value));
 function TimelineEditorWidget({ editor, blockId }) {
   const view = useTimelineData(editor, blockId);
@@ -28210,8 +26000,8 @@ function TimelineEditorWidget({ editor, blockId }) {
   const suppressClickEventId = useRef36(null);
   const [announcement, setAnnouncement] = useState44("");
   const dispatch = useCallback37(
-    (command2) => {
-      const result = applyTimelineCommand(editor, blockId, command2);
+    (command) => {
+      const result = applyTimelineCommand(editor, blockId, command);
       if (result.reason === "read-only") setAnnouncement("Timeline is read only.");
       if (result.reason === "unsafe-source") {
         setAnnouncement("Visual editing is paused until the timeline source is repaired.");
@@ -28421,7 +26211,7 @@ function TimelineEditorWidget({ editor, blockId }) {
                         onFinish: () => setEditingTrackId(null)
                       }
                     ),
-                    editable ? /* @__PURE__ */ jsxs40(Fragment16, { children: [
+                    editable ? /* @__PURE__ */ jsxs40(Fragment15, { children: [
                       /* @__PURE__ */ jsx51(
                         "button",
                         {
@@ -28919,7 +26709,7 @@ function navigateTrackPoints(event) {
 }
 
 // src/timeline/TimelineViewExtension.ts
-var TIMELINE_VIEW_KEY = new PluginKey9("squisq-timeline-view");
+var TIMELINE_VIEW_KEY = new PluginKey8("squisq-timeline-view");
 var detectCache3 = /* @__PURE__ */ new WeakMap();
 var parseCache3 = /* @__PURE__ */ new WeakMap();
 function fenceLangOf4(node2) {
@@ -29016,7 +26806,7 @@ function applyState6(tr, previous, editor, doc) {
   });
   return { entries, seq, decorations: buildDecorations7(doc, entries, editor) };
 }
-var TimelineViewExtension = Extension.create({
+var TimelineViewExtension = Extension8.create({
   name: "squisqTimelineView",
   addOptions() {
     return { enabled: true };
@@ -29025,7 +26815,7 @@ var TimelineViewExtension = Extension.create({
     const editor = this.editor;
     if (this.options.enabled === false) return [];
     return [
-      new Plugin9({
+      new Plugin8({
         key: TIMELINE_VIEW_KEY,
         state: {
           init: (_config, state) => {
@@ -29280,7 +27070,7 @@ function persistFromWrite(bodyMd, state) {
 // src/WysiwygEditor.tsx
 import { useCallback as useCallback38, useEffect as useEffect39, useMemo as useMemo35, useRef as useRef40, useState as useState49 } from "react";
 import { useEditor as useEditor2, EditorContent as EditorContent2 } from "@tiptap/react";
-import { Selection as Selection2 } from "@tiptap/pm/state";
+import { Selection } from "@tiptap/pm/state";
 import StarterKit2 from "@tiptap/starter-kit";
 import Table from "@tiptap/extension-table";
 import TableRow from "@tiptap/extension-table-row";
@@ -29313,11 +27103,12 @@ function createMermaidThemeStore(initialTheme) {
 }
 
 // src/blockTagActivity.ts
-import { Plugin as Plugin10, PluginKey as PluginKey10 } from "@tiptap/pm/state";
+import { Extension as Extension9 } from "@tiptap/core";
+import { Plugin as Plugin9, PluginKey as PluginKey9 } from "@tiptap/pm/state";
 import { Decoration as Decoration9, DecorationSet as DecorationSet9 } from "@tiptap/pm/view";
 var BLOCK_TAG_SELECTED_CLASS = "squisq-block-tags--selected";
 var BLOCK_TAG_HOVERED_CLASS = "squisq-block-tags--hovered";
-var BLOCK_TAG_ACTIVITY_KEY = new PluginKey10(
+var BLOCK_TAG_ACTIVITY_KEY = new PluginKey9(
   "squisq-block-tag-activity"
 );
 function isHeadingElement(element) {
@@ -29420,11 +27211,11 @@ function setHoveredPosition(view, hoveredPosition) {
     view.state.tr.setMeta(BLOCK_TAG_ACTIVITY_KEY, { hoveredPosition }).setMeta("addToHistory", false)
   );
 }
-var BlockTagActivityExtension = Extension.create({
+var BlockTagActivityExtension = Extension9.create({
   name: "squisqBlockTagActivity",
   addProseMirrorPlugins() {
     return [
-      new Plugin10({
+      new Plugin9({
         key: BLOCK_TAG_ACTIVITY_KEY,
         state: {
           init: (_config, state) => createPluginState(state.doc, state.selection.from, null),
@@ -29460,6 +27251,7 @@ var BlockTagActivityExtension = Extension.create({
 });
 
 // src/InlineIcon.ts
+import { Node as Node2, mergeAttributes } from "@tiptap/core";
 var InlineIcon = Node2.create({
   name: "inlineIcon",
   group: "inline",
@@ -29525,8 +27317,8 @@ function normalizeMalformedAssetUrl(src) {
 }
 
 // src/ImageNodeView.tsx
-import { Fragment as Fragment17, jsx as jsx53, jsxs as jsxs42 } from "react/jsx-runtime";
-function ImageComponent({ node: node2, selected, editor, updateAttributes: updateAttributes2 }) {
+import { Fragment as Fragment16, jsx as jsx53, jsxs as jsxs42 } from "react/jsx-runtime";
+function ImageComponent({ node: node2, selected, editor, updateAttributes }) {
   const { src, alt, title, width } = node2.attrs;
   const { mediaProvider, imageDisplayMode, openImageEdit, mediaRevision } = useEditorContext();
   const [resolvedSrc, setResolvedSrc] = useState47(src);
@@ -29584,7 +27376,7 @@ function ImageComponent({ node: node2, selected, editor, updateAttributes: updat
       const w = Math.round(finalWidth);
       const h2 = naturalW > 0 && naturalH > 0 ? Math.round(w * naturalH / naturalW) : null;
       setPreviewWidth(null);
-      updateAttributes2({ width: w, height: h2 });
+      updateAttributes({ width: w, height: h2 });
     };
     window.addEventListener("mousemove", onMove);
     window.addEventListener("mouseup", onUp);
@@ -29594,7 +27386,7 @@ function ImageComponent({ node: node2, selected, editor, updateAttributes: updat
     event.preventDefault();
     event.stopPropagation();
     setPreviewWidth(null);
-    updateAttributes2({ width: null, height: null });
+    updateAttributes({ width: null, height: null });
   };
   const baseStyle = isThumbnail ? {
     maxWidth: "100px",
@@ -29653,7 +27445,7 @@ function ImageComponent({ node: node2, selected, editor, updateAttributes: updat
             ]
           }
         ),
-        showResize && /* @__PURE__ */ jsxs42(Fragment17, { children: [
+        showResize && /* @__PURE__ */ jsxs42(Fragment16, { children: [
           /* @__PURE__ */ jsx53(
             "span",
             {
@@ -29715,6 +27507,7 @@ var ImageWithMediaProvider = Image.extend({
 });
 
 // src/tiptap/TiptapVideo.tsx
+import { Node as Node3, mergeAttributes as mergeAttributes2 } from "@tiptap/core";
 import { NodeViewWrapper as NodeViewWrapper2, ReactNodeViewRenderer as ReactNodeViewRenderer2 } from "@tiptap/react";
 
 // src/tiptap/useResolvedMediaSrc.ts
@@ -29761,7 +27554,7 @@ function normalizeVideoPlacement(value) {
 function normalizeLockToBlock(value) {
   return value !== false && value !== "false" && value !== 0 && value !== "0";
 }
-function VideoNodeView({ node: node2, updateAttributes: updateAttributes2, selected }) {
+function VideoNodeView({ node: node2, updateAttributes, selected }) {
   const {
     src,
     width,
@@ -29799,7 +27592,7 @@ function VideoNodeView({ node: node2, updateAttributes: updateAttributes2, selec
                   "aria-pressed": placement === option.value,
                   title: option.title,
                   onMouseDown: (event) => event.preventDefault(),
-                  onClick: () => updateAttributes2({ placement: option.value }),
+                  onClick: () => updateAttributes({ placement: option.value }),
                   children: option.label
                 },
                 option.value
@@ -29813,7 +27606,7 @@ function VideoNodeView({ node: node2, updateAttributes: updateAttributes2, selec
                   "aria-pressed": lockToBlock,
                   title: lockToBlock ? "Locked to this block; turn off for independent document timing" : "Document-timed; turn on to follow this block",
                   onMouseDown: (event) => event.preventDefault(),
-                  onClick: () => updateAttributes2({ lockToBlock: !lockToBlock }),
+                  onClick: () => updateAttributes({ lockToBlock: !lockToBlock }),
                   children: "Lock to block"
                 }
               )
@@ -29838,7 +27631,7 @@ function VideoNodeView({ node: node2, updateAttributes: updateAttributes2, selec
     }
   );
 }
-var TiptapVideo = Node2.create({
+var TiptapVideo = Node3.create({
   name: "video",
   group: "block",
   atom: true,
@@ -29914,19 +27707,20 @@ var TiptapVideo = Node2.create({
     return [{ tag: "video" }];
   },
   renderHTML({ HTMLAttributes }) {
-    return ["video", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    return ["video", mergeAttributes2(this.options.HTMLAttributes, HTMLAttributes)];
   },
   addNodeView() {
     return ReactNodeViewRenderer2(VideoNodeView);
   },
   addCommands() {
     return {
-      setVideo: (attrs) => ({ commands: commands2 }) => commands2.insertContent({ type: this.name, attrs })
+      setVideo: (attrs) => ({ commands }) => commands.insertContent({ type: this.name, attrs })
     };
   }
 });
 
 // src/tiptap/TiptapAudio.tsx
+import { Node as Node4, mergeAttributes as mergeAttributes3 } from "@tiptap/core";
 import { NodeViewWrapper as NodeViewWrapper3, ReactNodeViewRenderer as ReactNodeViewRenderer3 } from "@tiptap/react";
 import { jsx as jsx55 } from "react/jsx-runtime";
 function AudioNodeView({ node: node2 }) {
@@ -29934,7 +27728,7 @@ function AudioNodeView({ node: node2 }) {
   const resolvedSrc = useResolvedMediaSrc(src ?? "");
   return /* @__PURE__ */ jsx55(NodeViewWrapper3, { as: "span", className: "squisq-inline-audio-player", "data-drag-handle": true, draggable: true, children: /* @__PURE__ */ jsx55("audio", { src: resolvedSrc || void 0, controls, preload: "metadata" }) });
 }
-var TiptapAudio = Node2.create({
+var TiptapAudio = Node4.create({
   name: "audio",
   // Block-level so each recording lives on its own line in the WYSIWYG —
   // matches how the recorder inserts the tag (on a fresh line) and
@@ -29961,14 +27755,14 @@ var TiptapAudio = Node2.create({
     return [{ tag: "audio" }];
   },
   renderHTML({ HTMLAttributes }) {
-    return ["audio", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+    return ["audio", mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes)];
   },
   addNodeView() {
     return ReactNodeViewRenderer3(AudioNodeView);
   },
   addCommands() {
     return {
-      setAudio: (attrs) => ({ commands: commands2 }) => commands2.insertContent({ type: this.name, attrs })
+      setAudio: (attrs) => ({ commands }) => commands.insertContent({ type: this.name, attrs })
     };
   }
 });
@@ -29978,7 +27772,7 @@ import { profileBlockContents as profileBlockContents2, recommendTemplatesForBlo
 
 // src/MentionExtension.tsx
 import Mention from "@tiptap/extension-mention";
-import { PluginKey as PluginKey11 } from "@tiptap/pm/state";
+import { PluginKey as PluginKey10 } from "@tiptap/pm/state";
 var FALLBACK_KIND = "mention";
 function buildMentionExtension(getProvider) {
   return Mention.configure({
@@ -30034,7 +27828,7 @@ function buildMentionExtension(getProvider) {
           char: "@",
           // Custom plugin key so the mention suggestion doesn't collide
           // with any future `:` or `/` popovers.
-          pluginKey: new PluginKey11("mentionSuggestion"),
+          pluginKey: new PluginKey10("mentionSuggestion"),
           command: ({
             editor,
             range,
@@ -30929,7 +28723,7 @@ function insertImageNode(view, src, alt) {
 function moveSelectionToDropPoint(view, event) {
   const coords = view.posAtCoords({ left: event.clientX, top: event.clientY });
   if (!coords) return;
-  const tr = view.state.tr.setSelection(Selection2.near(view.state.doc.resolve(coords.pos)));
+  const tr = view.state.tr.setSelection(Selection.near(view.state.doc.resolve(coords.pos)));
   view.dispatch(tr);
 }
 
@@ -31144,7 +28938,7 @@ function sameEntries(a, b) {
 }
 
 // src/InlinePreviewGutter.tsx
-import { Fragment as Fragment18, jsx as jsx57, jsxs as jsxs45 } from "react/jsx-runtime";
+import { Fragment as Fragment17, jsx as jsx57, jsxs as jsxs45 } from "react/jsx-runtime";
 function isAnnotated(block) {
   const annotation = block.sourceHeading?.templateAnnotation;
   if (!annotation) return false;
@@ -31265,30 +29059,30 @@ function getTemplateDefaults(templateName, headingText2, bodyText, contents, ima
       return tableData ?? { headers: ["Column"], rows: [["Data"]] };
     }
     case "imageWithCaption": {
-      const first2 = images[0];
+      const first = images[0];
       return {
-        imageSrc: first2?.src ?? "",
-        imageAlt: first2?.alt ?? headingText2,
+        imageSrc: first?.src ?? "",
+        imageAlt: first?.alt ?? headingText2,
         caption: bodyText || headingText2,
         captionPosition: "bottom"
       };
     }
     case "leftFeature":
     case "rightFeature": {
-      const first2 = images[0];
+      const first = images[0];
       return {
-        imageSrc: first2?.src ?? "",
-        imageAlt: first2?.alt ?? headingText2,
-        imageWidth: first2?.width,
-        imageHeight: first2?.height,
+        imageSrc: first?.src ?? "",
+        imageAlt: first?.alt ?? headingText2,
+        imageWidth: first?.width,
+        imageHeight: first?.height,
         title: headingText2,
         body: bodyText
       };
     }
     case "videoWithCaption": {
-      const first2 = images[0];
+      const first = images[0];
       return {
-        videoSrc: first2?.src ?? "",
+        videoSrc: first?.src ?? "",
         caption: bodyText || headingText2,
         captionPosition: "bottom"
       };
@@ -31524,7 +29318,7 @@ function InlinePreviewGutter({
               children: [
                 /* @__PURE__ */ jsxs45("div", { className: "squisq-inline-preview-card-label", children: [
                   /* @__PURE__ */ jsx57("span", { className: "squisq-inline-preview-card-template", children: templateLabel(item.template) }),
-                  item.headingText && /* @__PURE__ */ jsxs45(Fragment18, { children: [
+                  item.headingText && /* @__PURE__ */ jsxs45(Fragment17, { children: [
                     /* @__PURE__ */ jsx57("span", { className: "squisq-inline-preview-card-sep", children: "\u2014" }),
                     /* @__PURE__ */ jsx57("span", { className: "squisq-inline-preview-card-title", children: item.headingText })
                   ] })
@@ -32572,7 +30366,7 @@ function CodeContextSectionView({
 }
 
 // src/codeContext/CodeContextZones.tsx
-import { Fragment as Fragment19, jsx as jsx60 } from "react/jsx-runtime";
+import { Fragment as Fragment18, jsx as jsx60 } from "react/jsx-runtime";
 function CodeContextZones({ options }) {
   const { monacoEditor } = useEditorContext();
   const [manager, setManager] = useState53(null);
@@ -32641,7 +30435,7 @@ function CodeContextZones({ options }) {
     [monacoEditor]
   );
   if (!manager) return null;
-  return /* @__PURE__ */ jsx60(Fragment19, { children: resolved.map(({ section }) => {
+  return /* @__PURE__ */ jsx60(Fragment18, { children: resolved.map(({ section }) => {
     const domNode = manager.getDomNode(section.id);
     if (!domNode) return null;
     return createPortal10(
@@ -33065,15 +30859,14 @@ function collectEmbeddedMedia(block) {
   (block.contents ?? []).forEach((node2) => visit(node2, void 0));
   return out;
 }
-function collectEmbeddedVideoSchedule(doc) {
+function collectEmbeddedMediaSchedule(doc) {
   const schedule = [];
   const visit = (blocks) => {
     for (const block of blocks) {
       collectEmbeddedMedia(block).forEach((media, index2) => {
-        if (media.kind !== "video") return;
         schedule.push({
           id: `embedded:${block.id}:${index2}`,
-          kind: "video",
+          kind: media.kind,
           src: media.src,
           absoluteStart: block.startTime,
           absoluteEnd: block.startTime + block.duration,
@@ -33089,6 +30882,27 @@ function collectEmbeddedVideoSchedule(doc) {
   visit(doc.blocks);
   return schedule;
 }
+function collectEmbeddedVideoSchedule(doc) {
+  return collectEmbeddedMediaSchedule(doc).filter((clip) => clip.kind === "video");
+}
+function collectTimelinePlaybackSchedule(doc, scheduled) {
+  const scheduledSources = new Set(scheduled.map((clip) => clip.src));
+  const narration = doc.audio.segments.map((segment, index2) => {
+    if (scheduledSources.has(segment.src)) return null;
+    return {
+      id: `narration:${index2}`,
+      kind: "audio",
+      src: segment.src,
+      absoluteStart: Math.max(0, segment.startTime),
+      absoluteEnd: Math.max(0, segment.startTime) + Math.max(0, segment.duration),
+      sourceIn: 0,
+      anchor: "document"
+    };
+  }).filter(
+    (clip) => clip !== null && clip.absoluteEnd > clip.absoluteStart
+  );
+  return [...scheduled, ...collectEmbeddedMediaSchedule(doc), ...narration];
+}
 
 // src/TimelineBlockPreview.tsx
 import { memo } from "react";
@@ -33130,11 +30944,30 @@ function advanceTime(prev, dt, total) {
   if (total <= 0) return 0;
   return Math.min(total, Math.max(0, prev + dt));
 }
+function playTimelineMediaAt(root, time) {
+  if (!root) return;
+  root.querySelectorAll("audio[data-clip-id], video[data-clip-id]").forEach((el) => {
+    const start = Number(el.dataset.absStart);
+    const end = Number(el.dataset.absEnd);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || time < start || time >= end) return;
+    try {
+      const pending = el.play();
+      pending?.catch(() => {
+      });
+    } catch {
+    }
+  });
+}
 function useTimelineClock(total) {
   const [currentTime, setCurrentTime] = useState54(0);
   const [isPlaying, setIsPlaying] = useState54(false);
   const rafRef = useRef45(null);
   const lastRef = useRef45(0);
+  const currentTimeRef = useRef45(0);
+  const isPlayingRef = useRef45(false);
+  const mediaHostRef = useRef45(null);
+  currentTimeRef.current = currentTime;
+  isPlayingRef.current = isPlaying;
   useEffect44(() => {
     setCurrentTime((t) => Math.min(t, Math.max(0, total)));
   }, [total]);
@@ -33146,7 +30979,9 @@ function useTimelineClock(total) {
       lastRef.current = now;
       setCurrentTime((prev) => {
         const next = advanceTime(prev, dt, total);
+        currentTimeRef.current = next;
         if (next >= total) {
+          isPlayingRef.current = false;
           setIsPlaying(false);
           return total;
         }
@@ -33159,17 +30994,34 @@ function useTimelineClock(total) {
       if (rafRef.current != null) cancelAnimationFrame(rafRef.current);
     };
   }, [isPlaying, total]);
+  const registerMediaHost = useCallback43((host) => {
+    mediaHostRef.current = host;
+  }, []);
   const play = useCallback43(() => {
-    setCurrentTime((t) => total > 0 && t >= total ? 0 : t);
+    const target = total > 0 && currentTimeRef.current >= total ? 0 : currentTimeRef.current;
+    currentTimeRef.current = target;
+    playTimelineMediaAt(mediaHostRef.current, target);
+    setCurrentTime(target);
+    isPlayingRef.current = true;
     setIsPlaying(true);
   }, [total]);
-  const pause = useCallback43(() => setIsPlaying(false), []);
-  const toggle = useCallback43(() => setIsPlaying((p) => !p), []);
+  const pause = useCallback43(() => {
+    isPlayingRef.current = false;
+    setIsPlaying(false);
+  }, []);
+  const toggle = useCallback43(() => {
+    if (isPlayingRef.current) pause();
+    else play();
+  }, [pause, play]);
   const seek = useCallback43(
-    (t) => setCurrentTime(Math.min(Math.max(0, t), Math.max(0, total))),
+    (t) => {
+      const next = Math.min(Math.max(0, t), Math.max(0, total));
+      currentTimeRef.current = next;
+      setCurrentTime(next);
+    },
     [total]
   );
-  return { currentTime, isPlaying, play, pause, toggle, seek };
+  return { currentTime, isPlaying, play, pause, toggle, seek, registerMediaHost };
 }
 
 // src/timelineMediaLabel.ts
@@ -33183,7 +31035,7 @@ function timelineMediaLabel(src, kind) {
 // src/TimelineItemMenu.tsx
 import { useEffect as useEffect45, useLayoutEffect as useLayoutEffect8, useRef as useRef46, useState as useState55 } from "react";
 import { createPortal as createPortal11 } from "react-dom";
-import { Fragment as Fragment20, jsx as jsx63, jsxs as jsxs49 } from "react/jsx-runtime";
+import { Fragment as Fragment19, jsx as jsx63, jsxs as jsxs49 } from "react/jsx-runtime";
 function TimelineItemMenu({
   anchor,
   target,
@@ -33387,7 +31239,7 @@ function VideoMenu({
         }
       )
     ] }),
-    placed && /* @__PURE__ */ jsxs49(Fragment20, { children: [
+    placed && /* @__PURE__ */ jsxs49(Fragment19, { children: [
       /* @__PURE__ */ jsxs49("label", { className: "squisq-timeline-item-menu-check", children: [
         /* @__PURE__ */ jsx63(
           "input",
@@ -33405,7 +31257,7 @@ function VideoMenu({
         ),
         /* @__PURE__ */ jsx63("span", { children: "Lock to block" })
       ] }),
-      placement === "picture-in-picture" && /* @__PURE__ */ jsxs49(Fragment20, { children: [
+      placement === "picture-in-picture" && /* @__PURE__ */ jsxs49(Fragment19, { children: [
         /* @__PURE__ */ jsxs49("label", { className: "squisq-timeline-item-menu-field", children: [
           /* @__PURE__ */ jsx63("span", { className: "squisq-timeline-item-menu-label", children: "PIP size" }),
           /* @__PURE__ */ jsxs49(
@@ -33606,10 +31458,10 @@ function headingLine(block) {
 }
 function TimelineTrack({
   height = 160,
+  basePath = "/",
   doc: docProp,
   clock,
-  schedule,
-  videoVisible = false
+  schedule
 }) {
   const {
     doc: contextDoc,
@@ -33643,10 +31495,15 @@ function TimelineTrack({
     [doc]
   );
   const clips = schedule ?? derivedClips;
+  const playbackClips = useMemo41(
+    () => doc ? collectTimelinePlaybackSchedule(doc, clips) : clips,
+    [clips, doc]
+  );
   const total = useMemo41(() => doc ? getDocPlaybackDuration(doc) : 0, [doc]);
   const width = Math.max(total * pxPerSecond, 200);
   const internalClock = useTimelineClock(total);
-  const { currentTime, isPlaying, play, pause, seek } = clock ?? internalClock;
+  const activeClock = clock ?? internalClock;
+  const { currentTime, isPlaying, play, pause, seek } = activeClock;
   const startPlay = useCallback44(() => {
     setDrag(null);
     play();
@@ -34250,13 +32107,13 @@ function TimelineTrack({
         }
       )
     ] }) }),
-    /* @__PURE__ */ jsx64("div", { className: "squisq-timeline-media-host", "aria-hidden": true, children: /* @__PURE__ */ jsx64(MediaContext5.Provider, { value: mediaProvider ?? null, children: /* @__PURE__ */ jsx64(
+    /* @__PURE__ */ jsx64("div", { ref: activeClock.registerMediaHost, className: "squisq-timeline-media-host", "aria-hidden": true, children: /* @__PURE__ */ jsx64(MediaContext5.Provider, { value: mediaProvider ?? null, children: /* @__PURE__ */ jsx64(
       MediaClipLayer,
       {
-        schedule: videoVisible ? clips.filter((clip) => clip.kind === "audio") : clips,
+        schedule: playbackClips,
         currentTime,
         isPlaying,
-        basePath: "/"
+        basePath
       }
     ) }) }),
     itemMenu && itemMenuTarget && /* @__PURE__ */ jsx64(
@@ -35473,8 +33330,8 @@ function PresentationModeControl() {
   useLayoutEffect9(() => {
     if (!open || !anchor) return;
     const checked = menuRef.current?.querySelector('[aria-checked="true"]');
-    const first2 = menuRef.current?.querySelector('[role="menuitemradio"]');
-    (checked ?? first2)?.focus();
+    const first = menuRef.current?.querySelector('[role="menuitemradio"]');
+    (checked ?? first)?.focus();
   }, [anchor, open]);
   return /* @__PURE__ */ jsxs54("div", { className: "squisq-presentation-control", children: [
     /* @__PURE__ */ jsx69(
@@ -35897,7 +33754,7 @@ function PrintPreview({
 }
 
 // src/PreviewPanel.tsx
-import { Fragment as Fragment21, jsx as jsx72, jsxs as jsxs57 } from "react/jsx-runtime";
+import { Fragment as Fragment20, jsx as jsx72, jsxs as jsxs57 } from "react/jsx-runtime";
 function PreviewPanel({
   basePath = "/",
   className,
@@ -36130,7 +33987,7 @@ function PreviewPanel({
         basePath,
         audioMode: previewProjection?.contentDoc.audio?.segments?.length ? "media" : "synthetic",
         showControls: !audience,
-        muted: true,
+        muted: audience,
         forceViewport: activeViewport,
         displayMode: activeDisplayMode,
         theme: activeTheme,
@@ -36160,7 +34017,7 @@ function PreviewPanel({
     minHeight: 0,
     background: presentation?.activeTarget ? activeTheme.colors.background : void 0
   };
-  return /* @__PURE__ */ jsxs57(Fragment21, { children: [
+  return /* @__PURE__ */ jsxs57(Fragment20, { children: [
     /* @__PURE__ */ jsx72(
       "div",
       {
@@ -36659,7 +34516,7 @@ ${formatSize(entry.size)}`,
 
 // src/DropZoneOverlay.tsx
 import { useState as useState63 } from "react";
-import { Fragment as Fragment22, jsx as jsx74, jsxs as jsxs59 } from "react/jsx-runtime";
+import { Fragment as Fragment21, jsx as jsx74, jsxs as jsxs59 } from "react/jsx-runtime";
 function DropZoneOverlay({
   dragContentType,
   zoneProps,
@@ -36680,7 +34537,7 @@ function DropZoneOverlay({
         variant: "media"
       }
     ),
-    showText && /* @__PURE__ */ jsxs59(Fragment22, { children: [
+    showText && /* @__PURE__ */ jsxs59(Fragment21, { children: [
       /* @__PURE__ */ jsx74(
         DropZone,
         {
@@ -37159,7 +35016,7 @@ import {
   createMediaProviderFromContainer
 } from "@bendyline/squisq/storage";
 import { MediaContext as MediaContext6, useMediaClipDurations } from "@bendyline/squisq-react";
-import { Fragment as Fragment23, jsx as jsx77, jsxs as jsxs60 } from "react/jsx-runtime";
+import { Fragment as Fragment22, jsx as jsx77, jsxs as jsxs60 } from "react/jsx-runtime";
 function EditorShell({
   initialMarkdown = "",
   initialView = "wysiwyg",
@@ -37318,7 +35175,7 @@ function EditorShell({
 function UseModeToolbarControls({ allowPrint }) {
   const printMode = usePrintMode();
   if (printMode.active) return /* @__PURE__ */ jsx77(PrintPreviewToolbar, {});
-  return /* @__PURE__ */ jsxs60(Fragment23, { children: [
+  return /* @__PURE__ */ jsxs60(Fragment22, { children: [
     /* @__PURE__ */ jsx77(PreviewToolbarControls, {}),
     /* @__PURE__ */ jsx77(PresentationModeControl, {}),
     allowPrint && /* @__PURE__ */ jsx77(PrintModeControl, {})
@@ -37882,7 +35739,7 @@ ${snippet}` : snippet);
                       doc: timelineDoc,
                       clock: timelineClock,
                       schedule: timelineSchedule,
-                      videoVisible: timelineVideoVisible || timelineCompositionVisible
+                      basePath
                     }
                   ),
                   statusBarVisible && !isImageMode && /* @__PURE__ */ jsx77(StatusBar, { slotRight: statusBarSlotRight }),