eddyter 1.4.18 → 1.4.19

package/dist/{index-CKRp6axU.js → index-q_TW8dU1.js}

@@ -1,14 +1,14 @@
 import { jsx as r, jsxs as p } from "react/jsx-runtime";
-import { useLexicalComposerContext as B } from "@lexical/react/LexicalComposerContext";
+import { useLexicalComposerContext as j } from "@lexical/react/LexicalComposerContext";
 import { $getNodeByKey as g } from "lexical";
-import { useState as E, useEffect as N } from "react";
-import { au as k, av as y, ak as I, aw as h, ax as T, ay as W } from "./index-CXyZgoBl.js";
+import { useState as B, useEffect as N } from "react";
+import { aF as k, aG as y, av as E, aH as h, aI as T, aJ as W } from "./index-Bex3G_eE.js";
 function $(e, t) {
   const d = e.split(".").pop()?.toLowerCase();
   return d === "pdf" || t.startsWith("data:application/pdf") ? "pdf" : d === "docx" || t.startsWith("data:application/vnd.openxmlformats") && e.toLowerCase().endsWith(".docx") ? "docx" : d === "xlsx" || d === "xls" || t.startsWith("data:application/vnd.openxmlformats-officedocument.spreadsheetml") || t.startsWith("data:application/vnd.ms-excel") ? "xlsx" : null;
 }
 function z(e, t) {
-  const [d, n] = E(null);
+  const [d, n] = B(null);
   return N(() => {
     const c = e && t ? $(t, e) : null;
     if (!e || !t || !c) {
@@ -16,15 +16,15 @@ function z(e, t) {
       return;
     }
     let l = !1;
-    return c === "pdf" ? import("./generatePdfThumbnail-CnldK2yE.js").then(({ generatePdfThumbnail: o }) => o(e)).then((o) => {
+    return c === "pdf" ? import("./generatePdfThumbnail-Cv2-ZCzh.js").then(({ generatePdfThumbnail: o }) => o(e)).then((o) => {
       l || n(o);
     }).catch(() => {
       l || n(null);
-    }) : c === "docx" ? import("./generateDocxThumbnail-RE7yNAXP.js").then(({ generateDocxThumbnail: o }) => o(e)).then((o) => {
+    }) : c === "docx" ? import("./generateDocxThumbnail-DBMxjZ83.js").then(({ generateDocxThumbnail: o }) => o(e)).then((o) => {
       l || n(o);
     }).catch(() => {
       l || n(null);
-    }) : c === "xlsx" && import("./generateXlsxThumbnail-BpBB4ePK.js").then(({ generateXlsxThumbnail: o }) => o(e)).then((o) => {
+    }) : c === "xlsx" && import("./generateXlsxThumbnail-UHmNc7Fa.js").then(({ generateXlsxThumbnail: o }) => o(e)).then((o) => {
       l || n(o);
     }).catch(() => {
       l || n(null);
@@ -36,10 +36,10 @@ function z(e, t) {
 const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFixed(1)} KB` : e < 1024 * 1024 * 1024 ? `${(e / (1024 * 1024)).toFixed(1)} MB` : `${(e / (1024 * 1024 * 1024)).toFixed(1)} GB` : "", D = (e) => {
   const t = e.split(".");
   return t.length > 1 ? t[t.length - 1].toLowerCase() : "";
-}, C = (e) => {
+}, F = (e) => {
   const t = D(e);
   return t === "pdf" || t === "docx" || t === "xlsx" || t === "xls";
-}, F = (e) => {
+}, C = (e) => {
   const t = D(e);
   return ["pdf", "doc", "docx", "txt", "odt"].includes(t) ? /* @__PURE__ */ r(h, { className: "cteditor-w-8 cteditor-h-8 cteditor-text-blue-600" }) : ["xls", "xlsx", "csv"].includes(t) ? /* @__PURE__ */ r(h, { className: "cteditor-w-8 cteditor-h-8 cteditor-text-green-600" }) : ["ppt", "pptx"].includes(t) ? /* @__PURE__ */ r(h, { className: "cteditor-w-8 cteditor-h-8 cteditor-text-red-600" }) : ["zip", "rar", "7z", "tar", "gz"].includes(t) ? /* @__PURE__ */ r(T, { className: "cteditor-w-8 cteditor-h-8 cteditor-text-orange-500" }) : /* @__PURE__ */ r(W, { className: "cteditor-w-8 cteditor-h-8 cteditor-text-gray-500" });
 }, H = ({
@@ -49,7 +49,7 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
   displayType: n = "card",
   nodeKey: c
 }) => {
-  const l = n === "inline" ? "inline" : "card", [o] = B(), u = z(C(t) ? e : void 0, t);
+  const l = n === "inline" ? "inline" : "card", [o] = j(), u = z(F(t) ? e : void 0, t);
   if (N(() => {
     u && o.update(() => {
       const a = g(c);
@@ -61,12 +61,12 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
     a.preventDefault(), a.stopPropagation();
     try {
       if (e.startsWith("data:")) {
-        const i = e.split(","), f = i[0].match(/:(.*?);/), L = f ? f[1] : "application/octet-stream", w = atob(i[1]);
-        let x = w.length;
-        const b = new Uint8Array(x);
+        const i = e.split(","), f = i[0].match(/:(.*?);/), L = f ? f[1] : "application/octet-stream", b = atob(i[1]);
+        let x = b.length;
+        const w = new Uint8Array(x);
         for (; x--; )
-          b[x] = w.charCodeAt(x);
-        const j = new Blob([b], { type: L }), v = URL.createObjectURL(j), s = document.createElement("a");
+          w[x] = b.charCodeAt(x);
+        const I = new Blob([w], { type: L }), v = URL.createObjectURL(I), s = document.createElement("a");
         s.href = v, s.download = t, s.style.display = "none", document.body.appendChild(s), s.click(), document.body.removeChild(s), setTimeout(() => URL.revokeObjectURL(v), 100);
       } else {
         const i = document.createElement("a");
@@ -80,7 +80,7 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
       const i = g(c);
       k(i) && i.remove();
     });
-  }, U = C(t) && u;
+  }, U = F(t) && u;
   return l === "inline" ? /* @__PURE__ */ p(
     "div",
     {
@@ -89,7 +89,7 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
       tabIndex: 0,
       "data-lexical-node-key": c,
       children: [
-        /* @__PURE__ */ r("span", { className: "cteditor-flex-shrink-0 *:cteditor-size-5", children: F(t) }),
+        /* @__PURE__ */ r("span", { className: "cteditor-flex-shrink-0 *:cteditor-size-5", children: C(t) }),
         /* @__PURE__ */ r("span", { className: "cteditor-flex-1 cteditor-min-w-0 cteditor-text-sm cteditor-font-medium cteditor-text-black cteditor-truncate", children: t }),
         /* @__PURE__ */ r(
           "button",
@@ -119,7 +119,7 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
             alt: "",
             className: "cteditor-w-full cteditor-h-full cteditor-object-cover"
           }
-        ) : /* @__PURE__ */ r("div", { className: "*:cteditor-size-8", children: F(t) }) }),
+        ) : /* @__PURE__ */ r("div", { className: "*:cteditor-size-8", children: C(t) }) }),
         /* @__PURE__ */ p("div", { className: "cteditor-flex cteditor-items-center cteditor-gap-2 cteditor-w-full", children: [
           /* @__PURE__ */ p("div", { className: "cteditor-flex-1 cteditor-min-w-0", children: [
             /* @__PURE__ */ r("div", { className: "cteditor-font-medium cteditor-text-xs cteditor-text-black cteditor-truncate", children: t }),
@@ -145,7 +145,7 @@ const R = (e) => e ? e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${(e / 1024).toFix
                 className: "cteditor-p-1 cteditor-rounded-md cteditor-text-black/80 hover:cteditor-bg-black/10 cteditor-transition-colors",
                 "aria-label": "Delete file",
                 title: "Delete file",
-                children: /* @__PURE__ */ r(I, { className: "cteditor-w-4 cteditor-h-4 cteditor-text-current" })
+                children: /* @__PURE__ */ r(E, { className: "cteditor-w-4 cteditor-h-4 cteditor-text-current" })
               }
             )
           ] })

package/dist/index.js

@@ -1,4 +1,4 @@
-import { aM as i, aN as r, aO as t, aP as s, aQ as o, aR as d, aS as u, aT as v, u as f, Q as n, aU as l, aV as w } from "./index-CXyZgoBl.js";
+import { aX as i, aY as r, aZ as t, a_ as s, a$ as o, b0 as d, b1 as b, b2 as u, u as v, a5 as f, b3 as n, b4 as l } from "./index-Bex3G_eE.js";
 export {
   i as ConfigurableEditor,
   r as ConfigurableEditorWithAuth,
@@ -6,10 +6,10 @@ export {
   s as EditorProvider,
   o as HtmlViewProvider,
   d as LinkPreviewHover,
-  u as defaultEditorConfig,
-  v as isReactNativeWebView,
-  f as useEditor,
-  n as useHtmlView,
-  l as useReactNativeBridge,
-  w as verifyApiKey
+  b as defaultEditorConfig,
+  u as isReactNativeWebView,
+  v as useEditor,
+  f as useHtmlView,
+  n as useReactNativeBridge,
+  l as verifyApiKey
 };

package/dist/nodes/AsterismNode.d.ts

@@ -0,0 +1,22 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+export type AsterismVariant = "asterism" | "triple-star" | "section";
+export type SerializedAsterismNode = Spread<{
+    variant: AsterismVariant;
+}, SerializedLexicalNode>;
+export declare class AsterismNode extends DecoratorNode<JSX.Element> {
+    __variant: AsterismVariant;
+    static getType(): string;
+    static clone(node: AsterismNode): AsterismNode;
+    constructor(variant?: AsterismVariant, key?: NodeKey);
+    static importJSON(serializedNode: SerializedAsterismNode): AsterismNode;
+    exportJSON(): SerializedAsterismNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    getVariant(): AsterismVariant;
+    setVariant(variant: AsterismVariant): void;
+    decorate(): JSX.Element;
+}
+export declare function $createAsterismNode(variant?: AsterismVariant): AsterismNode;
+export declare function $isAsterismNode(node: LexicalNode | null | undefined): node is AsterismNode;

package/dist/nodes/ButtonNode.d.ts

@@ -0,0 +1,37 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+export type ButtonVariant = "filled" | "outline";
+export type ButtonAlign = "left" | "center" | "right";
+export declare function sanitizeButtonHref(href: string): string;
+export type SerializedButtonNode = Spread<{
+    label: string;
+    href: string;
+    variant: ButtonVariant;
+    align: ButtonAlign;
+}, SerializedLexicalNode>;
+export declare class ButtonNode extends DecoratorNode<JSX.Element> {
+    __label: string;
+    __href: string;
+    __variant: ButtonVariant;
+    __align: ButtonAlign;
+    static getType(): string;
+    static clone(node: ButtonNode): ButtonNode;
+    constructor(label?: string, href?: string, variant?: ButtonVariant, align?: ButtonAlign, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedButtonNode;
+    static importJSON(serializedNode: SerializedButtonNode): ButtonNode;
+    getLabel(): string;
+    setLabel(label: string): void;
+    getHref(): string;
+    setHref(href: string): void;
+    getVariant(): ButtonVariant;
+    setVariant(variant: ButtonVariant): void;
+    getAlign(): ButtonAlign;
+    setAlign(align: ButtonAlign): void;
+    isInline(): false;
+    decorate(_editor: LexicalEditor): JSX.Element;
+}
+export declare function $createButtonNode(label?: string, href?: string, variant?: ButtonVariant, align?: ButtonAlign): ButtonNode;
+export declare function $isButtonNode(node: LexicalNode | null | undefined): node is ButtonNode;

package/dist/nodes/ColumnNode.d.ts

@@ -0,0 +1,44 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from '../../node_modules/lexical';
+export declare function clampColumnSpan(value: number | null | undefined): number;
+export type SerializedColumnNode = Spread<{
+    span: number;
+}, SerializedElementNode>;
+/**
+ * A single column inside a {@link ColumnsNode}. Holds any block-level content
+ * (paragraphs, headings, lists, images, …) but — by the nesting rules in the
+ * block spec — never another ColumnsNode (max nesting depth = 1).
+ *
+ * `__span` is how many grid tracks the column occupies. A normal column spans 1;
+ * "merging" two columns produces one wider column that spans 2 (or 3), so a row
+ * can be e.g. a narrow column beside a double-width one.
+ */
+export declare class ColumnNode extends ElementNode {
+    __span: number;
+    static getType(): string;
+    static clone(node: ColumnNode): ColumnNode;
+    constructor(span?: number, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ColumnNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedColumnNode;
+    static importJSON(serializedNode: SerializedColumnNode): ColumnNode;
+    getSpan(): number;
+    setSpan(span: number): void;
+    isShadowRoot(): boolean;
+    /** A column is always a self-contained block container, never inline. */
+    isInline(): false;
+    /** Keep empty columns alive so the placeholder + caret target persist. */
+    canBeEmpty(): true;
+    /** Text typed at the column boundary must land in a child block, not here. */
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+}
+/**
+ * @param withParagraph when true (default) seeds an empty paragraph so the
+ *        column has a caret target and survives Lexical normalization. Pass
+ *        false during import, where children arrive deserialized.
+ * @param span how many grid tracks the column occupies (1 = normal).
+ */
+export declare function $createColumnNode(withParagraph?: boolean, span?: number): ColumnNode;
+export declare function $isColumnNode(node: LexicalNode | null | undefined): node is ColumnNode;

package/dist/nodes/ColumnsNode.d.ts

@@ -0,0 +1,45 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from '../../node_modules/lexical';
+export type ColumnCount = 1 | 2 | 3;
+declare const MIN_COLUMNS = 1;
+declare const MAX_COLUMNS = 3;
+/**
+ * The count is the total number of grid *tracks* (the layout width in units),
+ * not the number of child columns — a merged/wide column spans more than one
+ * track, so `count` = the sum of every column's span (1–3).
+ */
+export declare function clampColumnCount(value: number | null | undefined): ColumnCount;
+export type SerializedColumnsNode = Spread<{
+    count: ColumnCount;
+}, SerializedElementNode>;
+/**
+ * A row of 2–3 {@link ColumnNode}s — the page-builder "columns" layout. Renders
+ * as a CSS grid that collapses to a single stack when the editor *container*
+ * (not the viewport) is narrow, via the `@container` query in blocks.css and the
+ * exported stylesheet. Nesting columns inside columns is disallowed (depth = 1).
+ */
+export declare class ColumnsNode extends ElementNode {
+    __count: ColumnCount;
+    static getType(): string;
+    static clone(node: ColumnsNode): ColumnsNode;
+    constructor(count?: ColumnCount, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ColumnsNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedColumnsNode;
+    static importJSON(serializedNode: SerializedColumnsNode): ColumnsNode;
+    getCount(): ColumnCount;
+    setCount(count: ColumnCount): void;
+    isInline(): false;
+    /** Always a self-contained layout block; never holds raw text directly. */
+    canBeEmpty(): false;
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+}
+/**
+ * @param withColumns when true (default) seeds `count` empty columns. Pass false
+ *        during import, where the ColumnNodes arrive deserialized as children.
+ */
+export declare function $createColumnsNode(count?: ColumnCount, withColumns?: boolean): ColumnsNode;
+export declare function $isColumnsNode(node: LexicalNode | null | undefined): node is ColumnsNode;
+export { MAX_COLUMNS, MIN_COLUMNS };

package/dist/nodes/EditorialFieldNode.d.ts

@@ -0,0 +1,32 @@
+import { DOMConversionMap, EditorConfig, ElementNode, LexicalNode, NodeKey, RangeSelection, SerializedElementNode, Spread } from '../../node_modules/lexical';
+export type EditorialFieldRole = "label" | "number" | "heading" | "quote" | "attribution";
+export type SerializedEditorialFieldNode = Spread<{
+    role: EditorialFieldRole;
+    placeholder: string;
+}, SerializedElementNode>;
+export declare class EditorialFieldNode extends ElementNode {
+    __role: EditorialFieldRole;
+    __placeholder: string;
+    static getType(): string;
+    static clone(node: EditorialFieldNode): EditorialFieldNode;
+    constructor(role: EditorialFieldRole, placeholder?: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: EditorialFieldNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): {
+        element: HTMLElement;
+    };
+    exportJSON(): SerializedEditorialFieldNode;
+    static importJSON(serializedNode: SerializedEditorialFieldNode): EditorialFieldNode;
+    getRole(): EditorialFieldRole;
+    isInline(): false;
+    /** Keep empty fields alive so the placeholder + caret target persist. */
+    canBeEmpty(): true;
+    /** New text typed at the boundary stays inside this field. */
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    /** Pressing Enter is handled by the plugin, not by splitting the field. */
+    insertNewAfter(_selection: RangeSelection, _restoreSelection?: boolean): null;
+}
+export declare function $createEditorialFieldNode(role: EditorialFieldRole, placeholder?: string): EditorialFieldNode;
+export declare function $isEditorialFieldNode(node: LexicalNode | null | undefined): node is EditorialFieldNode;

package/dist/nodes/FaqNode.d.ts

@@ -0,0 +1,28 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+export interface FaqItem {
+    q: string;
+    a: string;
+}
+export type SerializedFaqNode = Spread<{
+    items: FaqItem[];
+}, SerializedLexicalNode>;
+export declare class FaqNode extends DecoratorNode<JSX.Element> {
+    __items: FaqItem[];
+    static getType(): string;
+    static clone(node: FaqNode): FaqNode;
+    constructor(items?: FaqItem[], key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedFaqNode;
+    static importJSON(serializedNode: SerializedFaqNode): FaqNode;
+    getItems(): FaqItem[];
+    setItemField(index: number, field: "q" | "a", value: string): void;
+    addItem(): void;
+    removeItem(index: number): void;
+    isInline(): false;
+    decorate(_editor: LexicalEditor): JSX.Element;
+}
+export declare function $createFaqNode(items?: FaqItem[]): FaqNode;
+export declare function $isFaqNode(node: LexicalNode | null | undefined): node is FaqNode;

package/dist/nodes/ImagePlaceholderNode.d.ts

@@ -0,0 +1,15 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, SerializedLexicalNode } from '../../node_modules/lexical';
+export declare class ImagePlaceholderNode extends DecoratorNode<JSX.Element> {
+    static getType(): string;
+    static clone(node: ImagePlaceholderNode): ImagePlaceholderNode;
+    static importJSON(): ImagePlaceholderNode;
+    exportJSON(): SerializedLexicalNode;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    isInline(): false;
+    decorate(_editor: LexicalEditor): JSX.Element;
+}
+export declare function $createImagePlaceholderNode(): ImagePlaceholderNode;
+export declare function $isImagePlaceholderNode(node: LexicalNode | null | undefined): node is ImagePlaceholderNode;

package/dist/nodes/LabeledRuleNode.d.ts

@@ -0,0 +1,33 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from '../../node_modules/lexical';
+import { EditorialFieldNode } from './EditorialFieldNode';
+export type LabeledRuleStyle = "thin" | "thick" | "dashed" | "dotted";
+export type SerializedLabeledRuleNode = Spread<{
+    ruleStyle: LabeledRuleStyle;
+}, SerializedElementNode>;
+export declare class LabeledRuleNode extends ElementNode {
+    __ruleStyle: LabeledRuleStyle;
+    static getType(): string;
+    static clone(node: LabeledRuleNode): LabeledRuleNode;
+    constructor(ruleStyle?: LabeledRuleStyle, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: LabeledRuleNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedLabeledRuleNode;
+    static importJSON(serializedNode: SerializedLabeledRuleNode): LabeledRuleNode;
+    getRuleStyle(): LabeledRuleStyle;
+    setRuleStyle(ruleStyle: LabeledRuleStyle): void;
+    isInline(): false;
+    /** Always rendered as a self-contained block. */
+    canBeEmpty(): false;
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+}
+/**
+ * @param withField when true (default) seeds the editable label field. Pass
+ *        false during import, where the field arrives as a deserialized child.
+ */
+export declare function $createLabeledRuleNode(ruleStyle?: LabeledRuleStyle, withField?: boolean): LabeledRuleNode;
+export declare function $isLabeledRuleNode(node: LexicalNode | null | undefined): node is LabeledRuleNode;
+/** Returns the editable label field, if present. */
+export declare function $getLabeledRuleField(node: LabeledRuleNode): EditorialFieldNode | null;

package/dist/nodes/OrnamentDividerNode.d.ts

@@ -0,0 +1,22 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+export type OrnamentVariant = "star" | "flower" | "diamond" | "dot" | "section";
+export type SerializedOrnamentDividerNode = Spread<{
+    variant: OrnamentVariant;
+}, SerializedLexicalNode>;
+export declare class OrnamentDividerNode extends DecoratorNode<JSX.Element> {
+    __variant: OrnamentVariant;
+    static getType(): string;
+    static clone(node: OrnamentDividerNode): OrnamentDividerNode;
+    constructor(variant?: OrnamentVariant, key?: NodeKey);
+    static importJSON(serializedNode: SerializedOrnamentDividerNode): OrnamentDividerNode;
+    exportJSON(): SerializedOrnamentDividerNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    getVariant(): OrnamentVariant;
+    setVariant(variant: OrnamentVariant): void;
+    decorate(): JSX.Element;
+}
+export declare function $createOrnamentDividerNode(variant?: OrnamentVariant): OrnamentDividerNode;
+export declare function $isOrnamentDividerNode(node: LexicalNode | null | undefined): node is OrnamentDividerNode;

package/dist/nodes/PullQuoteRulesNode.d.ts

@@ -0,0 +1,32 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from '../../node_modules/lexical';
+import { EditorialFieldNode } from './EditorialFieldNode';
+export type PullQuoteRules = "full" | "short" | "none";
+export type SerializedPullQuoteRulesNode = Spread<{
+    rules: PullQuoteRules;
+}, SerializedElementNode>;
+export declare class PullQuoteRulesNode extends ElementNode {
+    __rules: PullQuoteRules;
+    static getType(): string;
+    static clone(node: PullQuoteRulesNode): PullQuoteRulesNode;
+    constructor(rules?: PullQuoteRules, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: PullQuoteRulesNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedPullQuoteRulesNode;
+    static importJSON(serializedNode: SerializedPullQuoteRulesNode): PullQuoteRulesNode;
+    getRules(): PullQuoteRules;
+    setRules(rules: PullQuoteRules): void;
+    isInline(): false;
+    canBeEmpty(): false;
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+}
+/**
+ * @param withFields when true (default) seeds the quote + attribution fields.
+ *        Pass false during import, where fields arrive as deserialized children.
+ */
+export declare function $createPullQuoteRulesNode(rules?: PullQuoteRules, withFields?: boolean): PullQuoteRulesNode;
+export declare function $isPullQuoteRulesNode(node: LexicalNode | null | undefined): node is PullQuoteRulesNode;
+/** [quoteField, attributionField] when present. */
+export declare function $getPullQuoteFields(node: PullQuoteRulesNode): EditorialFieldNode[];

package/dist/nodes/SectionNumberHeadingNode.d.ts

@@ -0,0 +1,42 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from '../../node_modules/lexical';
+import { EditorialFieldNode } from './EditorialFieldNode';
+/** Horizontal placement of the number + heading group. */
+export type SectionHeadingAlign = "left" | "center" | "right";
+export type SerializedSectionNumberHeadingNode = Spread<{
+    align: SectionHeadingAlign;
+    /** v2 hook (spec §11.2) — manual numbering only in v1, default false. */
+    autoNumber: boolean;
+}, SerializedElementNode>;
+export declare class SectionNumberHeadingNode extends ElementNode {
+    __align: SectionHeadingAlign;
+    __autoNumber: boolean;
+    static getType(): string;
+    static clone(node: SectionNumberHeadingNode): SectionNumberHeadingNode;
+    constructor(align?: SectionHeadingAlign, autoNumber?: boolean, key?: NodeKey);
+    /** CSS class list, including the `--autonumber` modifier when enabled. */
+    private buildClassName;
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: SectionNumberHeadingNode, dom: HTMLElement): boolean;
+    /** 1-based position among auto-numbered section headings before this one. */
+    private computeAutoNumber;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedSectionNumberHeadingNode;
+    static importJSON(serializedNode: SerializedSectionNumberHeadingNode): SectionNumberHeadingNode;
+    getAlign(): SectionHeadingAlign;
+    setAlign(align: SectionHeadingAlign): void;
+    getAutoNumber(): boolean;
+    setAutoNumber(autoNumber: boolean): void;
+    isInline(): false;
+    canBeEmpty(): false;
+    canInsertTextBefore(): false;
+    canInsertTextAfter(): false;
+}
+/**
+ * @param withFields when true (default) seeds the number + heading fields. Pass
+ *        false during import, where fields arrive as deserialized children.
+ */
+export declare function $createSectionNumberHeadingNode(align?: SectionHeadingAlign, autoNumber?: boolean, withFields?: boolean): SectionNumberHeadingNode;
+export declare function $isSectionNumberHeadingNode(node: LexicalNode | null | undefined): node is SectionNumberHeadingNode;
+/** [numberField, headingField] when present. */
+export declare function $getSectionFields(node: SectionNumberHeadingNode): EditorialFieldNode[];

package/dist/plugins/BlockLayoutPlugin.d.ts

@@ -0,0 +1,29 @@
+import { LexicalCommand } from '../../node_modules/lexical';
+import { ColumnCount, ColumnsNode } from '../nodes/ColumnsNode';
+export declare const INSERT_COLUMNS_COMMAND: LexicalCommand<ColumnCount | undefined>;
+export declare const INSERT_BUTTON_BLOCK_COMMAND: LexicalCommand<void>;
+export declare const INSERT_FAQ_COMMAND: LexicalCommand<void>;
+/** Appends an empty column, capped at MAX_COLUMNS tracks. Returns true if changed. */
+export declare function $addColumn(columns: ColumnsNode): boolean;
+/**
+ * Removes the last column (floored at one column). The column and its content
+ * are deleted together — removing a column removes what's in it, matching the
+ * prototype and user expectation.
+ */
+export declare function $removeColumn(columns: ColumnsNode): boolean;
+/**
+ * Merges the adjacent columns at `index` and `index + 1` into one wider column:
+ * the right column's content moves into the left one, whose span grows to cover
+ * both. Lets a 3-track row become e.g. a narrow column beside a double-width one.
+ * `index` is 0-based (0 merges columns 1 & 2, 1 merges columns 2 & 3).
+ */
+export declare function $mergeColumnsAt(columns: ColumnsNode, index: number): boolean;
+/** Convenience: merges the last two columns (used when there's only one pair). */
+export declare function $mergeColumns(columns: ColumnsNode): boolean;
+/**
+ * Splits the last wide (span > 1) column back into a narrower column plus a new
+ * empty single-track column — the inverse of {@link $mergeColumns}.
+ */
+export declare function $splitColumn(columns: ColumnsNode): boolean;
+declare const BlockLayoutPlugin: React.FC;
+export default BlockLayoutPlugin;

package/dist/plugins/ColumnAddButtonPlugin.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+/**
+ * Renders a small "+ block" button inside each column, matching the prototype's
+ * per-column affordance. Clicking it appends a paragraph to that column and
+ * opens the slash menu, so a block can be inserted directly into a single
+ * column (otherwise the caret + "/" is the only path). Positions are overlaid
+ * via a portal — the column DOM stays Lexical-managed and untouched.
+ */
+declare const ColumnAddButtonPlugin: React.FC<{
+    anchorElem?: HTMLElement;
+}>;
+export default ColumnAddButtonPlugin;

package/dist/plugins/CommentPlugin.commands.d.ts

@@ -3,3 +3,4 @@ export declare const INSERT_COMMENT_COMMAND: LexicalCommand<{
     text: string;
 }>;
 export declare const OPEN_COMMENT_MODAL_COMMAND: LexicalCommand<unknown>;
+export declare const OPEN_COMMENT_SIDEBAR_COMMAND: LexicalCommand<unknown>;

package/dist/plugins/CustomHorizontalRulePlugin/CustomHorizontalRuleNode.d.ts

@@ -1,10 +1,14 @@
 import { HorizontalRuleNode as BaseHorizontalRuleNode } from '../../../node_modules/@lexical/react/LexicalHorizontalRuleNode';
 import { DOMConversionMap, DOMExportOutput, LexicalCommand, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../../node_modules/lexical';
 export type LineStyle = "solid" | "dashed" | "dotted" | "double";
+/** Width variants for the plain rule (spec §04.2). "full" = 100%, others = % of column. */
+export type WidthVariant = "full" | "60" | "40" | "20";
+export declare const VALID_WIDTH_VARIANTS: WidthVariant[];
 export interface CustomHorizontalRulePayload {
     color?: string;
     strokeWidth?: number;
     lineStyle?: LineStyle;
+    width?: WidthVariant;
 }
 export interface OpenHorizontalRuleDialogPayload {
     editingNodeKey?: NodeKey;
@@ -13,6 +17,7 @@ export type SerializedCustomHorizontalRuleNode = Spread<{
     color?: string;
     strokeWidth?: number;
     lineStyle?: LineStyle;
+    width?: WidthVariant;
 }, SerializedLexicalNode>;
 export declare const INSERT_CUSTOM_HORIZONTAL_RULE_COMMAND: LexicalCommand<CustomHorizontalRulePayload>;
 /** Opens the horizontal rule customization dialog (e.g. from slash menu). */
@@ -21,9 +26,12 @@ export declare class CustomHorizontalRuleNode extends BaseHorizontalRuleNode {
     __color?: string;
     __strokeWidth?: number;
     __lineStyle?: LineStyle;
+    __width?: WidthVariant;
     static getType(): string;
     static clone(node: CustomHorizontalRuleNode): CustomHorizontalRuleNode;
-    constructor(color?: string, strokeWidth?: number, lineStyle?: LineStyle, key?: NodeKey);
+    constructor(color?: string, strokeWidth?: number, lineStyle?: LineStyle, width?: WidthVariant, key?: NodeKey);
+    /** Applies the width variant (percentage + centering) to a rule element. */
+    private applyWidth;
     createDOM(): HTMLElement;
     updateDOM(): boolean;
     static importDOM(): DOMConversionMap | null;
@@ -36,6 +44,8 @@ export declare class CustomHorizontalRuleNode extends BaseHorizontalRuleNode {
     setStrokeWidth(strokeWidth?: number): void;
     getLineStyle(): LineStyle | undefined;
     setLineStyle(lineStyle?: LineStyle): void;
+    getWidth(): WidthVariant | undefined;
+    setWidth(width?: WidthVariant): void;
 }
-export declare function $createCustomHorizontalRuleNode(color?: string, strokeWidth?: number, lineStyle?: LineStyle): CustomHorizontalRuleNode;
+export declare function $createCustomHorizontalRuleNode(color?: string, strokeWidth?: number, lineStyle?: LineStyle, width?: WidthVariant): CustomHorizontalRuleNode;
 export declare function $isCustomHorizontalRuleNode(node: LexicalNode | null | undefined): node is CustomHorizontalRuleNode;

package/dist/plugins/CustomHorizontalRulePlugin/HorizontalRuleCustomizationDialog.d.ts

@@ -1,6 +1,6 @@
 import { BaseSelection, LexicalEditor, NodeKey } from '../../../node_modules/lexical';
 import { default as React } from 'react';
-import { LineStyle } from './CustomHorizontalRuleNode';
+import { LineStyle, WidthVariant } from './CustomHorizontalRuleNode';
 interface HorizontalRuleCustomizationDialogProps {
     activeEditor: LexicalEditor;
     onClose: () => void;
@@ -10,6 +10,7 @@ interface HorizontalRuleCustomizationDialogProps {
         color: string;
         strokeWidth: number;
         lineStyle: LineStyle;
+        width?: WidthVariant;
     } | null;
 }
 declare const HorizontalRuleCustomizationDialog: React.FC<HorizontalRuleCustomizationDialogProps>;