@inshapardaz/likhari-react 0.1.14 → 0.1.15-dev.118

package/dist/EditorRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorRoot.d.ts","sourceRoot":"","sources":["../src/EditorRoot.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAY1D,OAAO,KAAK,EAA8B,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEjF,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAwB,KAAK,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAKzH,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAGjE,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAYhF,OAAO,EAAgC,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMnE,yEAAyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,YAAY,GAAG,KAAK,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IACrD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,uGAAuG;IACvG,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IACrC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;IAClD,iBAAiB,IAAI,OAAO,CAAC;IAC7B,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAQD,eAAO,MAAM,UAAU,uGAqXrB,CAAC"}
+{"version":3,"file":"EditorRoot.d.ts","sourceRoot":"","sources":["../src/EditorRoot.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAY1D,OAAO,KAAK,EAA8B,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEjF,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAwB,KAAK,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAKzH,OAAO,EAAyB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAKjE,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAYhF,OAAO,EAAgC,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMnE,yEAAyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,YAAY,GAAG,KAAK,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,aAAa,CAAC,EAAE,uBAAuB,CAAC;IACxC,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IACrD;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,uGAAuG;IACvG,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IACrC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;IAClD,iBAAiB,IAAI,OAAO,CAAC;IAC7B,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAQD,eAAO,MAAM,UAAU,uGAmXrB,CAAC"}

package/dist/EditorRoot.js

@@ -21,6 +21,8 @@ import { Toolbar } from './components/Toolbar.js';
 import { injectUrduWebFontsCss } from './fonts/index.js';
 import { LinkPastePlugin } from './plugins/LinkPastePlugin.js';
 import { PageBreakPlugin } from './plugins/PageBreakPlugin.js';
+import { LayoutPlugin } from './plugins/LayoutPlugin.js';
+import { FootnotePlugin } from './plugins/FootnotePlugin.js';
 import { DraftRestore } from './components/DraftRestore.js';
 import { LeaveDialog } from './components/LeaveDialog.js';
 import { clearDraft, createDraftId, hasDraftContent, pruneDrafts, writeDraft, } from './persistence/draftStorage.js';
@@ -277,7 +279,7 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
     const portalTargetSelector = `#${CSS.escape(portalTargetId)}`;
     return (_jsx(EditorThemeProvider, { theme: theme, colorScheme: colorScheme, accentColor: accentColor, scopeElementId: portalTargetId, children: _jsxs("div", { className: "likhari-root", dir: dir, ref: rootElementRef, "data-document-id": documentId, style: { height: typeof height === 'number' ? `${height}px` : height }, children: [_jsx("div", { id: portalTargetId, className: "likhari-portal-target" }), _jsx(PortalTargetContext.Provider, { value: portalTargetSelector, children: _jsxs(UiStringsContext.Provider, { value: strings, children: [_jsx(ImageOptionsContext.Provider, { value: imageOptions, children: _jsxs(LexicalComposer, { initialConfig: initialConfig, children: [_jsx(Toolbar, { config: config, onSave: handleSave, isDirty: isDirty, showSave: showSave, fontOptions: fontOptions, direction: dir, locale: locale, drafts: autosave
                                                 ? { currentId: draftId, maxBytes: autosaveMaxBytes, adoptOnRestore: !documentId, onRestored: handleDraftRestored }
-                                                : undefined }), documentId && (_jsx(DraftRestore, { draftId: documentId, mode: restoreDraft, initialJson: initialContentJsonRef.current, locale: locale, onRestored: handleDraftRestored })), _jsx("div", { className: "likhari-canvas", children: _jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "likhari-content-editable", dir: dir, "aria-label": strings.editor.contentLabel }), placeholder: _jsx("div", { className: "likhari-placeholder", children: resolvedPlaceholder }), ErrorBoundary: LexicalErrorBoundary }) }), config.history && _jsx(HistoryPlugin, {}), (config.lists.bullet || config.lists.numbered || config.lists.check) && _jsx(ListPlugin, {}), config.lists.check && _jsx(CheckListPlugin, {}), config.links && _jsx(LinkPlugin, {}), config.links && _jsx(LinkPastePlugin, {}), config.blocks.pageBreak && _jsx(PageBreakPlugin, {}), config.tables && _jsx(TablePlugin, { hasCellMerge: false, hasTabHandler: true }), config.blocks.horizontalRule && _jsx(HorizontalRulePlugin, {}), _jsx(EditorInstancePlugin, { instanceRef: editorInstanceRef }), _jsx(OnChangePlugin, { onChange: handleChange })] }) }), _jsx(LeaveDialog, { opened: leavePrompt !== null, canSave: Boolean(onSave), canSaveDraft: autosave || navigationGuard === 'save-draft', draftFailed: leavePrompt?.draftFailed ?? false, onSave: () => {
+                                                : undefined }), documentId && (_jsx(DraftRestore, { draftId: documentId, mode: restoreDraft, initialJson: initialContentJsonRef.current, locale: locale, onRestored: handleDraftRestored })), _jsx("div", { className: "likhari-canvas", children: _jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: "likhari-content-editable", dir: dir, "aria-label": strings.editor.contentLabel }), placeholder: _jsx("div", { className: "likhari-placeholder", children: resolvedPlaceholder }), ErrorBoundary: LexicalErrorBoundary }) }), config.history && _jsx(HistoryPlugin, {}), (config.lists.bullet || config.lists.numbered || config.lists.check) && _jsx(ListPlugin, {}), config.lists.check && _jsx(CheckListPlugin, {}), config.links && _jsx(LinkPlugin, {}), config.links && _jsx(LinkPastePlugin, {}), config.blocks.pageBreak && _jsx(PageBreakPlugin, {}), config.columns && _jsx(LayoutPlugin, {}), config.footnotes && _jsx(FootnotePlugin, {}), config.tables && _jsx(TablePlugin, { hasCellMerge: true, hasTabHandler: true }), config.blocks.horizontalRule && _jsx(HorizontalRulePlugin, {}), _jsx(EditorInstancePlugin, { instanceRef: editorInstanceRef }), _jsx(OnChangePlugin, { onChange: handleChange })] }) }), _jsx(LeaveDialog, { opened: leavePrompt !== null, canSave: Boolean(onSave), canSaveDraft: autosave || navigationGuard === 'save-draft', draftFailed: leavePrompt?.draftFailed ?? false, onSave: () => {
                                     handleSave();
                                     settleLeave(true);
                                 }, onSaveDraft: () => {

package/dist/blocks/FootnoteListNode.d.ts

@@ -0,0 +1,46 @@
+import { type DOMConversionMap, type DOMExportOutput, type EditorConfig, type LexicalNode, type NodeKey, type SerializedElementNode, type Spread, ElementNode } from 'lexical';
+export type SerializedFootnoteListNode = SerializedElementNode;
+export type SerializedFootnoteItemNode = Spread<{
+    footnoteId: string;
+}, SerializedElementNode>;
+/** The document's single footnote list, rendered at the end (requirements
+ * doc §4.10). An ordered-list-like container of FootnoteItemNode; its items'
+ * displayed numbers are a CSS counter (editor.css), same mechanism as
+ * FootnoteReferenceNode, so both sequences stay in sync as long as items
+ * are appended in the same order their references were inserted — which
+ * FootnotePlugin's insert command always does. */
+export declare class FootnoteListNode extends ElementNode {
+    static getType(): string;
+    static clone(node: FootnoteListNode): FootnoteListNode;
+    static importJSON(): FootnoteListNode;
+    exportJSON(): SerializedFootnoteListNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    isShadowRoot(): boolean;
+    insertNewAfter(): null;
+}
+export declare function $createFootnoteListNode(): FootnoteListNode;
+export declare function $isFootnoteListNode(node: LexicalNode | null | undefined): node is FootnoteListNode;
+/** One entry in the FootnoteListNode — the editable note text for a given
+ * footnoteId. Always keeps at least an empty paragraph (mirrors
+ * TableCellNode/LayoutItemNode). */
+export declare class FootnoteItemNode extends ElementNode {
+    __footnoteId: string;
+    constructor(footnoteId: string, key?: NodeKey);
+    static getType(): string;
+    static clone(node: FootnoteItemNode): FootnoteItemNode;
+    getFootnoteId(): string;
+    static importJSON(serializedNode: SerializedFootnoteItemNode): FootnoteItemNode;
+    exportJSON(): SerializedFootnoteItemNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $createFootnoteItemNode(footnoteId: string): FootnoteItemNode;
+export declare function $isFootnoteItemNode(node: LexicalNode | null | undefined): node is FootnoteItemNode;
+//# sourceMappingURL=FootnoteListNode.d.ts.map

package/dist/blocks/FootnoteListNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FootnoteListNode.d.ts","sourceRoot":"","sources":["../../src/blocks/FootnoteListNode.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC1B,KAAK,MAAM,EACX,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,CAAC;AAC/D,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,EAAE,qBAAqB,CAAC,CAAC;AAE/F;;;;;kDAKkD;AAClD,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB;IAItD,MAAM,CAAC,UAAU,IAAI,gBAAgB;IAIrC,UAAU,IAAI,0BAA0B;IAIxC,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C,SAAS,IAAI,eAAe;IAM5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,SAAS,IAAI,OAAO;IAIpB,YAAY,IAAI,OAAO;IAIvB,cAAc,IAAI,IAAI;CAGvB;AAED,wBAAgB,uBAAuB,IAAI,gBAAgB,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAElG;AAED;;oCAEoC;AACpC,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,YAAY,EAAE,MAAM,CAAC;gBAET,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAK7C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB;IAItD,aAAa,IAAI,MAAM;IAIvB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,0BAA0B,GAAG,gBAAgB;IAI/E,UAAU,IAAI,0BAA0B;IAIxC,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAU3C,SAAS,IAAI,eAAe;IAO5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAO5C,SAAS,IAAI,OAAO;IAIpB,UAAU,IAAI,KAAK;IAInB,SAAS,IAAI,KAAK;CAGnB;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAE5E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAElG"}

package/dist/blocks/FootnoteListNode.js

@@ -0,0 +1,117 @@
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, ElementNode, } from 'lexical';
+/** The document's single footnote list, rendered at the end (requirements
+ * doc §4.10). An ordered-list-like container of FootnoteItemNode; its items'
+ * displayed numbers are a CSS counter (editor.css), same mechanism as
+ * FootnoteReferenceNode, so both sequences stay in sync as long as items
+ * are appended in the same order their references were inserted — which
+ * FootnotePlugin's insert command always does. */
+export class FootnoteListNode extends ElementNode {
+    static getType() {
+        return 'footnote-list';
+    }
+    static clone(node) {
+        return new FootnoteListNode(node.__key);
+    }
+    static importJSON() {
+        return $createFootnoteListNode();
+    }
+    exportJSON() {
+        return { ...super.exportJSON(), type: 'footnote-list', version: 1 };
+    }
+    static importDOM() {
+        return {
+            ol: (domNode) => {
+                if (!domNode.hasAttribute('data-likhari-footnote-list'))
+                    return null;
+                return { conversion: () => ({ node: $createFootnoteListNode() }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('ol');
+        element.setAttribute('data-likhari-footnote-list', '');
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('ol');
+        addClassNamesToElement(element, config.theme.footnoteList ?? 'likhari-footnote-list');
+        return element;
+    }
+    updateDOM() {
+        return false;
+    }
+    isShadowRoot() {
+        return true;
+    }
+    insertNewAfter() {
+        return null;
+    }
+}
+export function $createFootnoteListNode() {
+    return $applyNodeReplacement(new FootnoteListNode());
+}
+export function $isFootnoteListNode(node) {
+    return node instanceof FootnoteListNode;
+}
+/** One entry in the FootnoteListNode — the editable note text for a given
+ * footnoteId. Always keeps at least an empty paragraph (mirrors
+ * TableCellNode/LayoutItemNode). */
+export class FootnoteItemNode extends ElementNode {
+    constructor(footnoteId, key) {
+        super(key);
+        this.__footnoteId = footnoteId;
+    }
+    static getType() {
+        return 'footnote-item';
+    }
+    static clone(node) {
+        return new FootnoteItemNode(node.__footnoteId, node.__key);
+    }
+    getFootnoteId() {
+        return this.getLatest().__footnoteId;
+    }
+    static importJSON(serializedNode) {
+        return $createFootnoteItemNode(serializedNode.footnoteId);
+    }
+    exportJSON() {
+        return { ...super.exportJSON(), type: 'footnote-item', version: 1, footnoteId: this.getFootnoteId() };
+    }
+    static importDOM() {
+        return {
+            li: (domNode) => {
+                const id = domNode.getAttribute('data-likhari-footnote-item');
+                if (!id)
+                    return null;
+                return { conversion: () => ({ node: $createFootnoteItemNode(id) }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('li');
+        element.setAttribute('id', `fn-${this.getFootnoteId()}`);
+        element.setAttribute('data-likhari-footnote-item', this.getFootnoteId());
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('li');
+        addClassNamesToElement(element, config.theme.footnoteItem ?? 'likhari-footnote-item');
+        element.id = `fn-${this.getFootnoteId()}`;
+        return element;
+    }
+    updateDOM() {
+        return false;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    canIndent() {
+        return false;
+    }
+}
+export function $createFootnoteItemNode(footnoteId) {
+    return $applyNodeReplacement(new FootnoteItemNode(footnoteId));
+}
+export function $isFootnoteItemNode(node) {
+    return node instanceof FootnoteItemNode;
+}

package/dist/blocks/FootnoteNode.d.ts

@@ -0,0 +1,38 @@
+import type { ReactElement } from 'react';
+import { DecoratorNode, type DOMConversionMap, type DOMExportOutput, type EditorConfig, type EditorState, type LexicalCommand, type LexicalNode, type NodeKey, type SerializedLexicalNode, type Spread } from 'lexical';
+export declare const INSERT_FOOTNOTE_COMMAND: LexicalCommand<void>;
+export type SerializedFootnoteReferenceNode = Spread<{
+    footnoteId: string;
+}, SerializedLexicalNode>;
+/** Inline marker in the text flow (requirements doc §4.10, architecture doc
+ * §3.3). Holds only an id — its displayed number is never stored, it's
+ * rendered by a CSS counter (editor.css) that counts these markers in DOM
+ * order, so insert/delete/reorder auto-renumbers with no JS bookkeeping.
+ * The note's actual content lives in a matching FootnoteItemNode inside the
+ * document's single FootnoteListNode, not here (same split as Lexical's own
+ * comments/annotations pattern: reference in the flow, content out-of-band). */
+export declare class FootnoteReferenceNode extends DecoratorNode<ReactElement> {
+    __footnoteId: string;
+    constructor(footnoteId: string, key?: NodeKey);
+    static getType(): string;
+    static clone(node: FootnoteReferenceNode): FootnoteReferenceNode;
+    getFootnoteId(): string;
+    static importJSON(serializedNode: SerializedFootnoteReferenceNode): FootnoteReferenceNode;
+    exportJSON(): SerializedFootnoteReferenceNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    getTextContent(): string;
+    isInline(): true;
+    decorate(): ReactElement;
+}
+export declare function $createFootnoteReferenceNode(footnoteId: string): FootnoteReferenceNode;
+export declare function $isFootnoteReferenceNode(node: LexicalNode | null | undefined): node is FootnoteReferenceNode;
+/** Resolves a reference's footnoteId from the editor state just before its
+ * deletion committed — a mutation listener's 'destroyed' entries only carry
+ * the NodeKey, and by the time the listener fires the *current* state no
+ * longer has the node, so the caller must pass the listener's own
+ * `prevEditorState` here to know which FootnoteItemNode to clean up. */
+export declare function $getFootnoteIdByKey(prevEditorState: EditorState, key: NodeKey): string | null;
+//# sourceMappingURL=FootnoteNode.d.ts.map

package/dist/blocks/FootnoteNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FootnoteNode.d.ts","sourceRoot":"","sources":["../../src/blocks/FootnoteNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,EAIL,aAAa,EAEb,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC1B,KAAK,MAAM,EACZ,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,IAAI,CAA4C,CAAC;AAEtG,MAAM,MAAM,+BAA+B,GAAG,MAAM,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,EAAE,qBAAqB,CAAC,CAAC;AAEpG;;;;;;gFAMgF;AAChF,qBAAa,qBAAsB,SAAQ,aAAa,CAAC,YAAY,CAAC;IACpE,YAAY,EAAE,MAAM,CAAC;gBAET,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAK7C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,qBAAqB,GAAG,qBAAqB;IAIhE,aAAa,IAAI,MAAM;IAIvB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,+BAA+B,GAAG,qBAAqB;IAIzF,UAAU,IAAI,+BAA+B;IAI7C,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAU3C,SAAS,IAAI,eAAe;IAU5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,SAAS,IAAI,OAAO;IAIpB,cAAc,IAAI,MAAM;IAIxB,QAAQ,IAAI,IAAI;IAIhB,QAAQ,IAAI,YAAY;CAKzB;AAED,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,qBAAqB,CAEtF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,qBAAqB,CAE5G;AAED;;;;wEAIwE;AACxE,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAO7F"}

package/dist/blocks/FootnoteNode.js

@@ -0,0 +1,90 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, $getNodeByKey, createCommand, DecoratorNode, } from 'lexical';
+export const INSERT_FOOTNOTE_COMMAND = createCommand('INSERT_FOOTNOTE_COMMAND');
+/** Inline marker in the text flow (requirements doc §4.10, architecture doc
+ * §3.3). Holds only an id — its displayed number is never stored, it's
+ * rendered by a CSS counter (editor.css) that counts these markers in DOM
+ * order, so insert/delete/reorder auto-renumbers with no JS bookkeeping.
+ * The note's actual content lives in a matching FootnoteItemNode inside the
+ * document's single FootnoteListNode, not here (same split as Lexical's own
+ * comments/annotations pattern: reference in the flow, content out-of-band). */
+export class FootnoteReferenceNode extends DecoratorNode {
+    constructor(footnoteId, key) {
+        super(key);
+        this.__footnoteId = footnoteId;
+    }
+    static getType() {
+        return 'footnote-reference';
+    }
+    static clone(node) {
+        return new FootnoteReferenceNode(node.__footnoteId, node.__key);
+    }
+    getFootnoteId() {
+        return this.getLatest().__footnoteId;
+    }
+    static importJSON(serializedNode) {
+        return $createFootnoteReferenceNode(serializedNode.footnoteId);
+    }
+    exportJSON() {
+        return { type: 'footnote-reference', version: 1, footnoteId: this.getFootnoteId() };
+    }
+    static importDOM() {
+        return {
+            sup: (domNode) => {
+                const id = domNode.getAttribute('data-likhari-footnote-ref');
+                if (!id)
+                    return null;
+                return { conversion: () => ({ node: $createFootnoteReferenceNode(id) }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('sup');
+        element.setAttribute('data-likhari-footnote-ref', this.getFootnoteId());
+        const anchor = document.createElement('a');
+        anchor.setAttribute('href', `#fn-${this.getFootnoteId()}`);
+        anchor.setAttribute('id', `fnref-${this.getFootnoteId()}`);
+        element.appendChild(anchor);
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('sup');
+        addClassNamesToElement(element, config.theme.footnoteReference ?? 'likhari-footnote-ref');
+        return element;
+    }
+    updateDOM() {
+        return false;
+    }
+    getTextContent() {
+        return `[^${this.getFootnoteId()}]`;
+    }
+    isInline() {
+        return true;
+    }
+    decorate() {
+        // The bracketed number itself is a CSS ::after counter (editor.css) —
+        // nothing to render here but the counted element.
+        return _jsx(_Fragment, {});
+    }
+}
+export function $createFootnoteReferenceNode(footnoteId) {
+    return $applyNodeReplacement(new FootnoteReferenceNode(footnoteId));
+}
+export function $isFootnoteReferenceNode(node) {
+    return node instanceof FootnoteReferenceNode;
+}
+/** Resolves a reference's footnoteId from the editor state just before its
+ * deletion committed — a mutation listener's 'destroyed' entries only carry
+ * the NodeKey, and by the time the listener fires the *current* state no
+ * longer has the node, so the caller must pass the listener's own
+ * `prevEditorState` here to know which FootnoteItemNode to clean up. */
+export function $getFootnoteIdByKey(prevEditorState, key) {
+    let id = null;
+    prevEditorState.read(() => {
+        const node = $getNodeByKey(key);
+        if ($isFootnoteReferenceNode(node))
+            id = node.getFootnoteId();
+    });
+    return id;
+}

package/dist/blocks/LayoutNode.d.ts

@@ -0,0 +1,54 @@
+import { type DOMConversionMap, type DOMExportOutput, type EditorConfig, type LexicalCommand, type LexicalNode, type NodeKey, type SerializedElementNode, type Spread, ElementNode } from 'lexical';
+/** Payload: how many (equal-width) columns to create. Ratio support beyond
+ * equal widths is deferred (lexical-editor-spec.md §4.9 mentions it as a
+ * "configurable" possibility, not a committed requirement for Phase 3). */
+export declare const INSERT_LAYOUT_COMMAND: LexicalCommand<{
+    columnCount: number;
+}>;
+export type SerializedLayoutContainerNode = Spread<{
+    templateColumns: string;
+}, SerializedElementNode>;
+export type SerializedLayoutItemNode = SerializedElementNode;
+/** A multi-column row (editor-architecture-design.md §3.2): an ElementNode
+ * holding one LayoutItemNode per column, laid out with CSS grid. Reused as
+ * the structural basis for two-column poetry layouts (spec §4.11). */
+export declare class LayoutContainerNode extends ElementNode {
+    __templateColumns: string;
+    constructor(templateColumns?: string, key?: NodeKey);
+    static getType(): string;
+    static clone(node: LayoutContainerNode): LayoutContainerNode;
+    getTemplateColumns(): string;
+    setTemplateColumns(templateColumns: string): this;
+    static importJSON(serializedNode: SerializedLayoutContainerNode): LayoutContainerNode;
+    exportJSON(): SerializedLayoutContainerNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: LayoutContainerNode, dom: HTMLElement): boolean;
+    canBeEmpty(): false;
+    isShadowRoot(): boolean;
+}
+export declare function $createLayoutContainerNode(templateColumns?: string): LayoutContainerNode;
+export declare function $isLayoutContainerNode(node: LexicalNode | null | undefined): node is LayoutContainerNode;
+/** One column's content area inside a LayoutContainerNode. Always keeps at
+ * least an empty paragraph (mirrors TableCellNode), so a column can never
+ * collapse to an unselectable, unfocusable void. */
+export declare class LayoutItemNode extends ElementNode {
+    static getType(): string;
+    static clone(node: LayoutItemNode): LayoutItemNode;
+    static importJSON(): LayoutItemNode;
+    exportJSON(): SerializedLayoutItemNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $createLayoutItemNode(): LayoutItemNode;
+export declare function $isLayoutItemNode(node: LexicalNode | null | undefined): node is LayoutItemNode;
+/** Builds a container with `columnCount` empty items — the shape every
+ * LAYOUT insert produces, and what the node-transform below re-normalizes
+ * a malformed tree back toward. */
+export declare function $createLayoutWithColumns(columnCount: number): LayoutContainerNode;
+//# sourceMappingURL=LayoutNode.d.ts.map

package/dist/blocks/LayoutNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutNode.d.ts","sourceRoot":"","sources":["../../src/blocks/LayoutNode.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC1B,KAAK,MAAM,EAEX,WAAW,EACZ,MAAM,SAAS,CAAC;AAGjB;;2EAE2E;AAC3E,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAA0C,CAAC;AAErH,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,EAAE,qBAAqB,CAAC,CAAC;AACvG,MAAM,MAAM,wBAAwB,GAAG,qBAAqB,CAAC;AAE7D;;sEAEsE;AACtE,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,iBAAiB,EAAE,MAAM,CAAC;gBAEd,eAAe,SAAmB,EAAE,GAAG,CAAC,EAAE,OAAO;IAK7D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,mBAAmB,GAAG,mBAAmB;IAI5D,kBAAkB,IAAI,MAAM;IAI5B,kBAAkB,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IAMjD,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,6BAA6B,GAAG,mBAAmB;IAIrF,UAAU,IAAI,6BAA6B;IAI3C,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAU3C,SAAS,IAAI,eAAe;IAQ5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAO5C,SAAS,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;IAOnE,UAAU,IAAI,KAAK;IAInB,YAAY,IAAI,OAAO;CAGxB;AAED,wBAAgB,0BAA0B,CAAC,eAAe,SAAmB,GAAG,mBAAmB,CAElG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,mBAAmB,CAExG;AAED;;oDAEoD;AACpD,qBAAa,cAAe,SAAQ,WAAW;IAC7C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc;IAIlD,MAAM,CAAC,UAAU,IAAI,cAAc;IAInC,UAAU,IAAI,wBAAwB;IAItC,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C,SAAS,IAAI,eAAe;IAM5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,SAAS,IAAI,OAAO;IAIpB,UAAU,IAAI,KAAK;IAInB,SAAS,IAAI,KAAK;CAGnB;AAED,wBAAgB,qBAAqB,IAAI,cAAc,CAEtD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,cAAc,CAE9F;AAED;;mCAEmC;AACnC,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,CAOjF"}

package/dist/blocks/LayoutNode.js

@@ -0,0 +1,138 @@
+import { $applyNodeReplacement, $createParagraphNode, createCommand, ElementNode, } from 'lexical';
+import { addClassNamesToElement } from '@lexical/utils';
+/** Payload: how many (equal-width) columns to create. Ratio support beyond
+ * equal widths is deferred (lexical-editor-spec.md §4.9 mentions it as a
+ * "configurable" possibility, not a committed requirement for Phase 3). */
+export const INSERT_LAYOUT_COMMAND = createCommand('INSERT_LAYOUT_COMMAND');
+/** A multi-column row (editor-architecture-design.md §3.2): an ElementNode
+ * holding one LayoutItemNode per column, laid out with CSS grid. Reused as
+ * the structural basis for two-column poetry layouts (spec §4.11). */
+export class LayoutContainerNode extends ElementNode {
+    constructor(templateColumns = 'repeat(2, 1fr)', key) {
+        super(key);
+        this.__templateColumns = templateColumns;
+    }
+    static getType() {
+        return 'layout-container';
+    }
+    static clone(node) {
+        return new LayoutContainerNode(node.__templateColumns, node.__key);
+    }
+    getTemplateColumns() {
+        return this.getLatest().__templateColumns;
+    }
+    setTemplateColumns(templateColumns) {
+        const writable = this.getWritable();
+        writable.__templateColumns = templateColumns;
+        return writable;
+    }
+    static importJSON(serializedNode) {
+        return $createLayoutContainerNode(serializedNode.templateColumns);
+    }
+    exportJSON() {
+        return { ...super.exportJSON(), type: 'layout-container', version: 1, templateColumns: this.getTemplateColumns() };
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (!domNode.hasAttribute('data-likhari-layout-container'))
+                    return null;
+                const templateColumns = domNode.style.gridTemplateColumns || undefined;
+                return { conversion: () => ({ node: $createLayoutContainerNode(templateColumns) }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.setAttribute('data-likhari-layout-container', '');
+        element.style.display = 'grid';
+        element.style.gridTemplateColumns = this.getTemplateColumns();
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('div');
+        addClassNamesToElement(element, config.theme.layoutContainer ?? 'likhari-layout-container');
+        element.style.gridTemplateColumns = this.__templateColumns;
+        return element;
+    }
+    updateDOM(prevNode, dom) {
+        if (prevNode.__templateColumns !== this.__templateColumns) {
+            dom.style.gridTemplateColumns = this.__templateColumns;
+        }
+        return false;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    isShadowRoot() {
+        return true;
+    }
+}
+export function $createLayoutContainerNode(templateColumns = 'repeat(2, 1fr)') {
+    return $applyNodeReplacement(new LayoutContainerNode(templateColumns));
+}
+export function $isLayoutContainerNode(node) {
+    return node instanceof LayoutContainerNode;
+}
+/** One column's content area inside a LayoutContainerNode. Always keeps at
+ * least an empty paragraph (mirrors TableCellNode), so a column can never
+ * collapse to an unselectable, unfocusable void. */
+export class LayoutItemNode extends ElementNode {
+    static getType() {
+        return 'layout-item';
+    }
+    static clone(node) {
+        return new LayoutItemNode(node.__key);
+    }
+    static importJSON() {
+        return $createLayoutItemNode();
+    }
+    exportJSON() {
+        return { ...super.exportJSON(), type: 'layout-item', version: 1 };
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (!domNode.hasAttribute('data-likhari-layout-item'))
+                    return null;
+                return { conversion: () => ({ node: $createLayoutItemNode() }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.setAttribute('data-likhari-layout-item', '');
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('div');
+        addClassNamesToElement(element, config.theme.layoutItem ?? 'likhari-layout-item');
+        return element;
+    }
+    updateDOM() {
+        return false;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    canIndent() {
+        return false;
+    }
+}
+export function $createLayoutItemNode() {
+    return $applyNodeReplacement(new LayoutItemNode());
+}
+export function $isLayoutItemNode(node) {
+    return node instanceof LayoutItemNode;
+}
+/** Builds a container with `columnCount` empty items — the shape every
+ * LAYOUT insert produces, and what the node-transform below re-normalizes
+ * a malformed tree back toward. */
+export function $createLayoutWithColumns(columnCount) {
+    const count = Math.max(2, Math.min(6, Math.round(columnCount)));
+    const container = $createLayoutContainerNode(`repeat(${count}, 1fr)`);
+    for (let i = 0; i < count; i++) {
+        container.append($createLayoutItemNode().append($createParagraphNode()));
+    }
+    return container;
+}

package/dist/blocks/footnoteActions.d.ts

@@ -0,0 +1,9 @@
+/** Inserts a reference at the caret and a matching empty item at the end of
+ * the document's footnote list (creating the list if this is the first
+ * footnote), then focuses the new item so the user can type the note. */
+export declare function $insertFootnote(): boolean;
+/** Removes the FootnoteItemNode for `footnoteId`, and the FootnoteListNode
+ * itself if that was its last item — called by FootnotePlugin's mutation
+ * listener when a FootnoteReferenceNode is deleted from the text. */
+export declare function $removeFootnoteItem(footnoteId: string): void;
+//# sourceMappingURL=footnoteActions.d.ts.map

package/dist/blocks/footnoteActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footnoteActions.d.ts","sourceRoot":"","sources":["../../src/blocks/footnoteActions.ts"],"names":[],"mappings":"AAcA;;yEAEyE;AACzE,wBAAgB,eAAe,IAAI,OAAO,CAgBzC;AAED;;qEAEqE;AACrE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAM5D"}

package/dist/blocks/footnoteActions.js

@@ -0,0 +1,42 @@
+import { $createParagraphNode, $getRoot, $getSelection, $isRangeSelection } from 'lexical';
+import { $createFootnoteReferenceNode } from './FootnoteNode.js';
+import { $createFootnoteItemNode, $createFootnoteListNode, $isFootnoteItemNode, $isFootnoteListNode } from './FootnoteListNode.js';
+let counter = 0;
+/** Short, collision-resistant within a single document: a monotonic counter
+ * is enough here (ids never need to be stable/meaningful across documents),
+ * and avoids a hard dependency on crypto.randomUUID being available. */
+function newFootnoteId() {
+    counter += 1;
+    return `${Date.now().toString(36)}${counter.toString(36)}`;
+}
+/** Inserts a reference at the caret and a matching empty item at the end of
+ * the document's footnote list (creating the list if this is the first
+ * footnote), then focuses the new item so the user can type the note. */
+export function $insertFootnote() {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+        return false;
+    const footnoteId = newFootnoteId();
+    selection.insertNodes([$createFootnoteReferenceNode(footnoteId)]);
+    const root = $getRoot();
+    const lastChild = root.getLastChild();
+    const list = $isFootnoteListNode(lastChild) ? lastChild : $createFootnoteListNode();
+    if (!$isFootnoteListNode(lastChild))
+        root.append(list);
+    const item = $createFootnoteItemNode(footnoteId).append($createParagraphNode());
+    list.append(item);
+    item.getFirstDescendant()?.selectStart();
+    return true;
+}
+/** Removes the FootnoteItemNode for `footnoteId`, and the FootnoteListNode
+ * itself if that was its last item — called by FootnotePlugin's mutation
+ * listener when a FootnoteReferenceNode is deleted from the text. */
+export function $removeFootnoteItem(footnoteId) {
+    const list = $getRoot().getChildren().find($isFootnoteListNode);
+    if (!list)
+        return;
+    const item = list.getChildren().find((child) => $isFootnoteItemNode(child) && child.getFootnoteId() === footnoteId);
+    item?.remove();
+    if (list.getChildrenSize() === 0)
+        list.remove();
+}

package/dist/blocks/layoutActions.d.ts

@@ -0,0 +1,12 @@
+import { LayoutContainerNode, LayoutItemNode } from './LayoutNode.js';
+/** Inserts a `columnCount`-column layout right after the selection's
+ * top-level block, and focuses its first column. Returns false (so the
+ * command falls through) when there's no usable selection to anchor on. */
+export declare function $insertLayout(columnCount: number): boolean;
+/** Keeps LayoutContainerNode/LayoutItemNode nesting valid against malformed
+ * trees from paste, undo or JSON import — a LayoutItemNode can only live
+ * directly inside a LayoutContainerNode and vice versa. */
+export declare function $normalizeLayoutItem(node: LayoutItemNode): void;
+/** See $normalizeLayoutItem — the container-side half of the same rule. */
+export declare function $normalizeLayoutContainer(node: LayoutContainerNode): void;
+//# sourceMappingURL=layoutActions.d.ts.map

package/dist/blocks/layoutActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutActions.d.ts","sourceRoot":"","sources":["../../src/blocks/layoutActions.ts"],"names":[],"mappings":"AACA,OAAO,EAAuE,mBAAmB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAExI;;2EAE2E;AAC3E,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAQ1D;AAED;;2DAE2D;AAC3D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAM/D;AAED,2EAA2E;AAC3E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CASzE"}

package/dist/blocks/layoutActions.js

@@ -0,0 +1,39 @@
+import { $getSelection, $isRangeSelection } from 'lexical';
+import { $createLayoutWithColumns, $isLayoutContainerNode, $isLayoutItemNode } from './LayoutNode.js';
+/** Inserts a `columnCount`-column layout right after the selection's
+ * top-level block, and focuses its first column. Returns false (so the
+ * command falls through) when there's no usable selection to anchor on. */
+export function $insertLayout(columnCount) {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection))
+        return false;
+    const anchorTopLevel = selection.anchor.getNode().getTopLevelElementOrThrow();
+    const container = $createLayoutWithColumns(columnCount);
+    anchorTopLevel.insertAfter(container);
+    container.getFirstDescendant()?.selectStart();
+    return true;
+}
+/** Keeps LayoutContainerNode/LayoutItemNode nesting valid against malformed
+ * trees from paste, undo or JSON import — a LayoutItemNode can only live
+ * directly inside a LayoutContainerNode and vice versa. */
+export function $normalizeLayoutItem(node) {
+    const parent = node.getParent();
+    if ($isLayoutContainerNode(parent))
+        return;
+    // Orphaned: unwrap into plain content rather than leaving a stray node.
+    for (const child of node.getChildren())
+        node.insertBefore(child);
+    node.remove();
+}
+/** See $normalizeLayoutItem — the container-side half of the same rule. */
+export function $normalizeLayoutContainer(node) {
+    const children = node.getChildren();
+    if (children.length === 0) {
+        node.remove();
+        return;
+    }
+    for (const child of children) {
+        if (!$isLayoutItemNode(child))
+            child.remove();
+    }
+}