@inshapardaz/likhari-react 0.1.18 → 0.1.19-dev.182

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;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"}
+{"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;AAOjE,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAahF,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,uGA2XrB,CAAC"}

package/dist/EditorRoot.js

@@ -23,7 +23,10 @@ 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 { PoetryPlugin } from './plugins/PoetryPlugin.js';
+import { PoetryResizer } from './blocks/PoetryResizer.js';
 import { DraftRestore } from './components/DraftRestore.js';
+import { FindReplaceBar } from './components/FindReplaceBar.js';
 import { LeaveDialog } from './components/LeaveDialog.js';
 import { clearDraft, createDraftId, hasDraftContent, pruneDrafts, writeDraft, } from './persistence/draftStorage.js';
 import { ImageOptionsContext } from './image/ImageOptionsContext.js';
@@ -65,6 +68,7 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
     const editorStateRef = useRef(null);
     const lastSavedJsonRef = useRef(null);
     const [isDirty, setIsDirty] = useState(false);
+    const [findOpen, setFindOpen] = useState(false);
     const isDirtyRef = useRef(isDirty);
     isDirtyRef.current = isDirty;
     const autosaveTimerRef = useRef(null);
@@ -277,9 +281,9 @@ export const EditorRoot = forwardRef(function EditorRoot({ documentId, initialCo
     // rather than colliding on a shared one.
     const portalTargetId = useId();
     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
+    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, findOpen: findOpen, onToggleFind: () => setFindOpen((v) => !v), 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.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: () => {
+                                                : undefined }), documentId && (_jsx(DraftRestore, { draftId: documentId, mode: restoreDraft, initialJson: initialContentJsonRef.current, locale: locale, onRestored: handleDraftRestored })), _jsxs("div", { className: "likhari-canvas-frame", children: [config.findReplace && findOpen && _jsx(FindReplaceBar, { strings: strings, dir: dir, onClose: () => setFindOpen(false) }), _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.poetry.enabled && _jsx(PoetryPlugin, {}), config.poetry.enabled && _jsx(PoetryResizer, {}), 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/PoetryNode.d.ts

@@ -0,0 +1,70 @@
+import { type DOMConversionMap, type DOMExportOutput, type EditorConfig, type LexicalNode, type NodeKey, type SerializedElementNode, type Spread, ElementNode } from 'lexical';
+export type PoetryLayout = 'single' | 'two-column' | 'staggered';
+/** Vertical space between couplets — an ordered scale the menu steps through. */
+export declare const POETRY_SPACINGS: readonly ["compact", "normal", "relaxed", "loose"];
+export type PoetrySpacing = (typeof POETRY_SPACINGS)[number];
+export declare const DEFAULT_POETRY_SPACING: PoetrySpacing;
+/** Horizontal space either side of the divider in two-column layout. */
+export declare const POETRY_GUTTERS: readonly ["compact", "normal", "relaxed", "loose"];
+export type PoetryGutter = (typeof POETRY_GUTTERS)[number];
+export declare const DEFAULT_POETRY_GUTTER: PoetryGutter;
+/** Width of each couplet box in staggered layout, as a share of the block. */
+export declare const POETRY_STAGGERS: readonly ["compact", "normal", "relaxed", "loose"];
+export type PoetryStagger = (typeof POETRY_STAGGERS)[number];
+export declare const DEFAULT_POETRY_STAGGER: PoetryStagger;
+export type SerializedPoetryBlockNode = Spread<{
+    layout: PoetryLayout;
+    width?: number;
+    spacing?: PoetrySpacing;
+    gutter?: PoetryGutter;
+    stagger?: PoetryStagger;
+}, SerializedElementNode>;
+/**
+ * A poetry *section*: one or more couplets (two-line verse units) sharing
+ * one layout — single-column stacks each couplet's two misras directly as
+ * paragraph children (two per couplet, in order), two-column gives each
+ * couplet its own LayoutContainerNode row (built on the columns primitive,
+ * §4.9) — see blocks/poetryActions.ts's $getCouplets for how either shape
+ * is read, and $setPoetryLayout/$exitPoetryOnEnter for how children are
+ * restructured/grown between couplets and layouts. `layout` applies to the
+ * whole section, not per couplet, and mutates in place via poetryActions so
+ * converting a section between layouts doesn't lose selection/undo
+ * coherence. One extensible primitive in place of four fixed templates,
+ * per requirements doc §4.11.
+ */
+export declare class PoetryBlockNode extends ElementNode {
+    __layout: PoetryLayout;
+    /** User-chosen width in px (drag-resized), overriding editor.css's default
+     * max-width: 70%. Undefined until the user resizes it. */
+    __width?: number;
+    __spacing: PoetrySpacing;
+    __gutter: PoetryGutter;
+    __stagger: PoetryStagger;
+    constructor(layout?: PoetryLayout, width?: number, spacing?: PoetrySpacing, gutter?: PoetryGutter, stagger?: PoetryStagger, key?: NodeKey);
+    static getType(): string;
+    static clone(node: PoetryBlockNode): PoetryBlockNode;
+    getLayout(): PoetryLayout;
+    getWidth(): number | undefined;
+    setWidth(width: number | undefined): this;
+    /** Attribute-only — restructuring children for a layout change is
+     * poetryActions.ts's $setPoetryLayout, not a node method, since it needs
+     * $-context tree mutations beyond this node's own state. */
+    setLayoutAttribute(layout: PoetryLayout): this;
+    getSpacing(): PoetrySpacing;
+    setSpacing(spacing: PoetrySpacing): this;
+    getGutter(): PoetryGutter;
+    setGutter(gutter: PoetryGutter): this;
+    getStagger(): PoetryStagger;
+    setStagger(stagger: PoetryStagger): this;
+    static importJSON(serializedNode: SerializedPoetryBlockNode): PoetryBlockNode;
+    exportJSON(): SerializedPoetryBlockNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: PoetryBlockNode, dom: HTMLElement, config: EditorConfig): boolean;
+    canBeEmpty(): false;
+    isShadowRoot(): boolean;
+}
+export declare function $createPoetryBlockNode(layout?: PoetryLayout, width?: number, spacing?: PoetrySpacing, gutter?: PoetryGutter, stagger?: PoetryStagger): PoetryBlockNode;
+export declare function $isPoetryBlockNode(node: LexicalNode | null | undefined): node is PoetryBlockNode;
+//# sourceMappingURL=PoetryNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PoetryNode.d.ts","sourceRoot":"","sources":["../../src/blocks/PoetryNode.tsx"],"names":[],"mappings":"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"}

package/dist/blocks/PoetryNode.js

@@ -0,0 +1,198 @@
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, ElementNode, } from 'lexical';
+/** Vertical space between couplets — an ordered scale the menu steps through. */
+export const POETRY_SPACINGS = ['compact', 'normal', 'relaxed', 'loose'];
+export const DEFAULT_POETRY_SPACING = 'normal';
+/** Horizontal space either side of the divider in two-column layout. */
+export const POETRY_GUTTERS = ['compact', 'normal', 'relaxed', 'loose'];
+export const DEFAULT_POETRY_GUTTER = 'normal';
+/** Width of each couplet box in staggered layout, as a share of the block. */
+export const POETRY_STAGGERS = ['compact', 'normal', 'relaxed', 'loose'];
+export const DEFAULT_POETRY_STAGGER = 'normal';
+const VALID_LAYOUTS = new Set(['single', 'two-column', 'staggered']);
+const VALID_SPACINGS = new Set(POETRY_SPACINGS);
+const VALID_GUTTERS = new Set(POETRY_GUTTERS);
+const VALID_STAGGERS = new Set(POETRY_STAGGERS);
+/** Poetry is always justified: `text-align-last: justify` stretches a
+ * one-line misra across the full column width too, not just wrapped lines,
+ * so every line reads edge-to-edge. */
+function applyJustifyStyle(element) {
+    element.style.textAlign = 'justify';
+    element.style.textAlignLast = 'justify';
+}
+/** A user-dragged width overrides editor.css's default max-width: 70% —
+ * clearing the inline style (rather than setting it to that same 70%)
+ * lets the CSS default keep tracking the canvas if it's ever resized. */
+function applyWidthStyle(element, width) {
+    if (width === undefined)
+        element.style.removeProperty('max-width');
+    else
+        element.style.maxWidth = `${width}px`;
+}
+/**
+ * A poetry *section*: one or more couplets (two-line verse units) sharing
+ * one layout — single-column stacks each couplet's two misras directly as
+ * paragraph children (two per couplet, in order), two-column gives each
+ * couplet its own LayoutContainerNode row (built on the columns primitive,
+ * §4.9) — see blocks/poetryActions.ts's $getCouplets for how either shape
+ * is read, and $setPoetryLayout/$exitPoetryOnEnter for how children are
+ * restructured/grown between couplets and layouts. `layout` applies to the
+ * whole section, not per couplet, and mutates in place via poetryActions so
+ * converting a section between layouts doesn't lose selection/undo
+ * coherence. One extensible primitive in place of four fixed templates,
+ * per requirements doc §4.11.
+ */
+export class PoetryBlockNode extends ElementNode {
+    constructor(layout = 'single', width, spacing = DEFAULT_POETRY_SPACING, gutter = DEFAULT_POETRY_GUTTER, stagger = DEFAULT_POETRY_STAGGER, key) {
+        super(key);
+        this.__layout = layout;
+        this.__width = width;
+        this.__spacing = spacing;
+        this.__gutter = gutter;
+        this.__stagger = stagger;
+    }
+    static getType() {
+        return 'poetry-couplet';
+    }
+    static clone(node) {
+        return new PoetryBlockNode(node.__layout, node.__width, node.__spacing, node.__gutter, node.__stagger, node.__key);
+    }
+    getLayout() {
+        return this.getLatest().__layout;
+    }
+    getWidth() {
+        return this.getLatest().__width;
+    }
+    setWidth(width) {
+        const writable = this.getWritable();
+        writable.__width = width;
+        return writable;
+    }
+    /** Attribute-only — restructuring children for a layout change is
+     * poetryActions.ts's $setPoetryLayout, not a node method, since it needs
+     * $-context tree mutations beyond this node's own state. */
+    setLayoutAttribute(layout) {
+        const writable = this.getWritable();
+        writable.__layout = layout;
+        return writable;
+    }
+    getSpacing() {
+        return this.getLatest().__spacing;
+    }
+    setSpacing(spacing) {
+        const writable = this.getWritable();
+        writable.__spacing = spacing;
+        return writable;
+    }
+    getGutter() {
+        return this.getLatest().__gutter;
+    }
+    setGutter(gutter) {
+        const writable = this.getWritable();
+        writable.__gutter = gutter;
+        return writable;
+    }
+    getStagger() {
+        return this.getLatest().__stagger;
+    }
+    setStagger(stagger) {
+        const writable = this.getWritable();
+        writable.__stagger = stagger;
+        return writable;
+    }
+    static importJSON(serializedNode) {
+        return $createPoetryBlockNode(serializedNode.layout, serializedNode.width, serializedNode.spacing, serializedNode.gutter, serializedNode.stagger);
+    }
+    exportJSON() {
+        const width = this.getWidth();
+        return {
+            ...super.exportJSON(),
+            type: 'poetry-couplet',
+            version: 1,
+            layout: this.getLayout(),
+            spacing: this.getSpacing(),
+            gutter: this.getGutter(),
+            stagger: this.getStagger(),
+            ...(width !== undefined ? { width } : {}),
+        };
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                const rawLayout = domNode.getAttribute('data-likhari-poetry-layout');
+                if (!rawLayout)
+                    return null;
+                const layout = VALID_LAYOUTS.has(rawLayout) ? rawLayout : 'single';
+                const rawWidth = Number(domNode.getAttribute('data-likhari-poetry-width'));
+                const width = Number.isFinite(rawWidth) && rawWidth > 0 ? rawWidth : undefined;
+                const rawSpacing = domNode.getAttribute('data-likhari-poetry-spacing');
+                const spacing = VALID_SPACINGS.has(rawSpacing) ? rawSpacing : DEFAULT_POETRY_SPACING;
+                const rawGutter = domNode.getAttribute('data-likhari-poetry-gutter');
+                const gutter = VALID_GUTTERS.has(rawGutter) ? rawGutter : DEFAULT_POETRY_GUTTER;
+                const rawStagger = domNode.getAttribute('data-likhari-poetry-stagger');
+                const stagger = VALID_STAGGERS.has(rawStagger) ? rawStagger : DEFAULT_POETRY_STAGGER;
+                return { conversion: () => ({ node: $createPoetryBlockNode(layout, width, spacing, gutter, stagger) }), priority: 2 };
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.setAttribute('data-likhari-poetry-layout', this.getLayout());
+        element.setAttribute('data-likhari-poetry-spacing', this.getSpacing());
+        element.setAttribute('data-likhari-poetry-gutter', this.getGutter());
+        element.setAttribute('data-likhari-poetry-stagger', this.getStagger());
+        const width = this.getWidth();
+        if (width !== undefined)
+            element.setAttribute('data-likhari-poetry-width', String(width));
+        applyJustifyStyle(element);
+        applyWidthStyle(element, width);
+        return { element };
+    }
+    createDOM(config) {
+        const element = document.createElement('div');
+        const base = config.theme.poetry ?? 'likhari-poetry';
+        addClassNamesToElement(element, base, `${base}--${this.__layout}`, `${base}--spacing-${this.__spacing}`, `${base}--gutter-${this.__gutter}`, `${base}--stagger-${this.__stagger}`);
+        applyJustifyStyle(element);
+        applyWidthStyle(element, this.__width);
+        return element;
+    }
+    // Only ever adds/removes modifier classes, never touches the element's full
+    // className — the reconciler separately classList.adds the per-block ltr/rtl
+    // theme class (editor.css) onto this same element, and a wholesale className
+    // reassignment here would silently wipe it out.
+    updateDOM(prevNode, dom, config) {
+        const base = config.theme.poetry ?? 'likhari-poetry';
+        if (prevNode.__layout !== this.__layout) {
+            dom.classList.remove(`${base}--${prevNode.__layout}`);
+            dom.classList.add(`${base}--${this.__layout}`);
+        }
+        if (prevNode.__spacing !== this.__spacing) {
+            dom.classList.remove(`${base}--spacing-${prevNode.__spacing}`);
+            dom.classList.add(`${base}--spacing-${this.__spacing}`);
+        }
+        if (prevNode.__gutter !== this.__gutter) {
+            dom.classList.remove(`${base}--gutter-${prevNode.__gutter}`);
+            dom.classList.add(`${base}--gutter-${this.__gutter}`);
+        }
+        if (prevNode.__stagger !== this.__stagger) {
+            dom.classList.remove(`${base}--stagger-${prevNode.__stagger}`);
+            dom.classList.add(`${base}--stagger-${this.__stagger}`);
+        }
+        if (prevNode.__width !== this.__width) {
+            applyWidthStyle(dom, this.__width);
+        }
+        return false;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    isShadowRoot() {
+        return true;
+    }
+}
+export function $createPoetryBlockNode(layout = 'single', width, spacing = DEFAULT_POETRY_SPACING, gutter = DEFAULT_POETRY_GUTTER, stagger = DEFAULT_POETRY_STAGGER) {
+    return $applyNodeReplacement(new PoetryBlockNode(layout, width, spacing, gutter, stagger));
+}
+export function $isPoetryBlockNode(node) {
+    return node instanceof PoetryBlockNode;
+}

package/dist/blocks/PoetryResizer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A floating drag handle over the currently-active poetry couplet's
+ * inline-end edge, letting the user resize how wide the block reads on the
+ * page — "size it according to the length of the couplet" — rather than
+ * being stuck with editor.css's default max-width: 70%. Rendered as a
+ * portal into the editor's own portal-target element, never as a child of
+ * the couplet's own DOM, so it can't interfere with Lexical's
+ * reconciliation of the couplet's real (editable) children.
+ */
+export declare function PoetryResizer(): import("react").JSX.Element | null;
+//# sourceMappingURL=PoetryResizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PoetryResizer.d.ts","sourceRoot":"","sources":["../../src/blocks/PoetryResizer.tsx"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,wBAAgB,aAAa,uCAqF5B"}

package/dist/blocks/PoetryResizer.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getNodeByKey } from 'lexical';
+import { usePortalTarget } from '../PortalTargetContext.js';
+import { $getPoetryBlockFromSelection } from './poetryActions.js';
+import { $isPoetryBlockNode } from './PoetryNode.js';
+const MIN_WIDTH_PX = 160;
+function measure(el) {
+    const box = el.getBoundingClientRect();
+    return { top: box.top, left: box.left, width: box.width, height: box.height, rtl: getComputedStyle(el).direction === 'rtl' };
+}
+/**
+ * A floating drag handle over the currently-active poetry couplet's
+ * inline-end edge, letting the user resize how wide the block reads on the
+ * page — "size it according to the length of the couplet" — rather than
+ * being stuck with editor.css's default max-width: 70%. Rendered as a
+ * portal into the editor's own portal-target element, never as a child of
+ * the couplet's own DOM, so it can't interfere with Lexical's
+ * reconciliation of the couplet's real (editable) children.
+ */
+export function PoetryResizer() {
+    const [editor] = useLexicalComposerContext();
+    const portalSelector = usePortalTarget();
+    const [activeKey, setActiveKey] = useState(null);
+    const [box, setBox] = useState(null);
+    const dragStart = useRef(null);
+    useEffect(() => {
+        const recompute = () => {
+            if (dragStart.current)
+                return; // the pointermove handler owns `box` mid-drag
+            editor.getEditorState().read(() => {
+                const couplet = $getPoetryBlockFromSelection();
+                const el = couplet ? editor.getElementByKey(couplet.getKey()) : null;
+                if (!couplet || !el) {
+                    setActiveKey(null);
+                    setBox(null);
+                    return;
+                }
+                setActiveKey(couplet.getKey());
+                setBox(measure(el));
+            });
+        };
+        recompute();
+        const unregister = editor.registerUpdateListener(recompute);
+        window.addEventListener('resize', recompute);
+        window.addEventListener('scroll', recompute, true);
+        return () => {
+            unregister();
+            window.removeEventListener('resize', recompute);
+            window.removeEventListener('scroll', recompute, true);
+        };
+    }, [editor]);
+    if (!box || !activeKey)
+        return null;
+    const onPointerDown = (event) => {
+        event.preventDefault();
+        event.currentTarget.setPointerCapture(event.pointerId);
+        dragStart.current = { x: event.clientX, width: box.width, rtl: box.rtl };
+    };
+    const onPointerMove = (event) => {
+        const start = dragStart.current;
+        const el = editor.getElementByKey(activeKey);
+        if (!start || !el)
+            return;
+        const delta = event.clientX - start.x;
+        const signedDelta = start.rtl ? -delta : delta;
+        const canvasMax = editor.getRootElement()?.clientWidth ?? start.width + signedDelta;
+        const width = Math.round(Math.min(Math.max(start.width + signedDelta, MIN_WIDTH_PX), canvasMax));
+        // Live visual feedback: the couplet is centered (margin: auto), so
+        // resizing it moves both edges — re-measure after mutating rather than
+        // computing the new position from the drag delta alone.
+        el.style.maxWidth = `${width}px`;
+        setBox(measure(el));
+    };
+    const onPointerUp = () => {
+        const start = dragStart.current;
+        dragStart.current = null;
+        const el = editor.getElementByKey(activeKey);
+        const width = el ? Math.round(el.getBoundingClientRect().width) : null;
+        if (start && width !== null) {
+            editor.update(() => {
+                const node = $getNodeByKey(activeKey);
+                if ($isPoetryBlockNode(node))
+                    node.setWidth(width);
+            });
+        }
+    };
+    const handleX = box.rtl ? box.left : box.left + box.width;
+    const handle = (_jsx("div", { className: "likhari-poetry-resize-handle", style: { position: 'fixed', top: box.top, left: handleX, height: box.height }, onPointerDown: onPointerDown, onPointerMove: onPointerMove, onPointerUp: onPointerUp, role: "separator", "aria-orientation": "vertical" }));
+    const portalRoot = portalSelector ? document.querySelector(portalSelector) : null;
+    return portalRoot ? createPortal(handle, portalRoot) : handle;
+}

package/dist/blocks/poetryActions.d.ts

@@ -0,0 +1,117 @@
+import { type ParagraphNode } from 'lexical';
+import { type PoetryBlockNode, type PoetryLayout } from './PoetryNode.js';
+/** One couplet's two misra paragraphs, in order. */
+export type Couplet = [ParagraphNode, ParagraphNode];
+/**
+ * A poetry block is a *section* of one or more couplets sharing one layout
+ * (single-column stacks each couplet's two misras directly as paragraph
+ * children, two deep per couplet; two-column gives each couplet its own
+ * LayoutContainerNode row). This walks that structure and returns each
+ * couplet as a pair, in document order — the one place that knows how to
+ * read either shape, so nothing else needs to.
+ */
+export declare function $getCouplets(node: PoetryBlockNode): Couplet[];
+/** Every misra in the block, flattened across all its couplets — for
+ * operations (like $setPoetryLayout) that don't care about couplet
+ * boundaries, just the full set of lines. */
+export declare function $getMisraParagraphs(node: PoetryBlockNode): ParagraphNode[];
+/** The PoetryBlockNode the current selection is inside, or null. */
+export declare function $getPoetryBlockFromSelection(): PoetryBlockNode | null;
+/**
+ * The explicit "Insert couplet above/below" menu actions — mirrors the
+ * table menu's "Insert row before/after". Targets the couplet the caret is
+ * currently in, falling back to the block's last couplet (so the toolbar's
+ * always-available insert button has somewhere sensible to act on even
+ * without a precise caret position).
+ */
+export declare function $insertCoupletRelativeToSelection(position: 'before' | 'after'): boolean;
+/**
+ * Converts every couplet in the block between single-column (two stacked
+ * misras) and two-column (built on the columns primitive, §4.9) in place —
+ * pulls each couplet's two misra paragraphs out of whichever shape
+ * currently holds them and rebuilds the other shape around the same
+ * paragraph nodes, preserving couplet order, so content, selection and
+ * undo history all survive the conversion.
+ */
+export declare function $setPoetryLayout(node: PoetryBlockNode, layout: PoetryLayout): void;
+/** A block at the very end of the document would otherwise leave no
+ * editable block to click or arrow down into — appends one empty paragraph
+ * if the block doesn't already have a next sibling. Idempotent: once a
+ * sibling exists (that paragraph, or anything else), this is a no-op, so
+ * it's safe to call from both the insert command and a node transform that
+ * keeps the invariant even after later edits (e.g. deleting the trailing
+ * paragraph, or JSON content loaded without one). */
+export declare function $ensureTrailingParagraph(node: PoetryBlockNode): void;
+/**
+ * Inserts a poetry couplet at the caret. If the caret is already inside a
+ * poetry block, inserts a new couplet right after the one the caret is in
+ * (same as the "Insert couplet below" menu action — table-row-insert
+ * semantics, in its existing layout: "one poetry block can contain one or
+ * more couplets, in one or two column layout", so a block's layout is
+ * fixed once it has couplets, not chosen per couplet) and focuses its first
+ * misra. Otherwise creates a new block (in `layout`) with one
+ * couplet, after the selection's top-level element.
+ */
+export declare function $insertPoetryCouplet(layout: PoetryLayout): boolean;
+/** Removes the couplet the selection is inside. If it's the block's only
+ * couplet, removes the whole block (an empty poetry section serves no
+ * purpose) — the explicit, always-available counterpart to
+ * $deletePoetryOnBackspace's empty-couplet shortcut (mirrors the table
+ * menu's own "Delete table" action). */
+export declare function $deletePoetryCouplet(): boolean;
+/**
+ * Backspace at the start of a misra never merges it into its neighbour: the
+ * block's lines are paired into couplets, so merging one line away would
+ * shift every couplet after it (and take the previous couplet's last line
+ * with it). Instead, Backspace at the start of an empty couplet removes that
+ * couplet, and at the start of any other line it moves the caret to the end
+ * of the previous line. Other caret positions (deleting within text) fall
+ * through to normal handling.
+ */
+export declare function $deletePoetryOnBackspace(): boolean;
+/**
+ * Forward Delete at the end of a misra never merges the next line into it, for
+ * the same reason as $deletePoetryOnBackspace: the caret moves to the start of
+ * the next line instead. Other caret positions fall through to normal handling.
+ */
+export declare function $deletePoetryForward(): boolean;
+/**
+ * Enter inside a poetry block never grows a couplet past its fixed two
+ * misras. The block's *last* couplet being completely empty is always the
+ * exit trigger, regardless of which of its two (both-empty) misras the
+ * caret happens to be on — pressing Enter once on a non-empty last couplet
+ * appends a fresh empty one to continue into ("new couplet after last"),
+ * and pressing Enter again on that still-untouched couplet exits ("double
+ * enter to exit the block"): the same empty-item convention most editors
+ * use for lists. Outside that case: pressed in a couplet's first misra,
+ * Enter moves the caret to the second (already there; nothing inserted —
+ * this is what stops ParagraphNode's default insertNewAfter from growing
+ * the couplet, which would otherwise insert the new paragraph as a sibling
+ * of wherever the caret was, i.e. still inside the couplet); pressed in
+ * the last misra of a couplet that isn't the block's last, it moves to the
+ * next couplet's first misra.
+ */
+export declare function $exitPoetryOnEnter(): boolean;
+/** Steps the caret's poetry block one notch looser (+1) or tighter (-1) on
+ * the couplet-spacing scale; clamps at either end. */
+export declare function $adjustPoetrySpacing(step: 1 | -1): boolean;
+/** Steps the caret's two-column gutter one notch wider (+1) or narrower (-1);
+ * clamps at either end. */
+export declare function $adjustPoetryGutter(step: 1 | -1): boolean;
+/** Steps the caret's staggered couplet width one notch narrower (-1) or wider
+ * (+1); clamps at either end. */
+export declare function $adjustPoetryStagger(step: 1 | -1): boolean;
+/** Whether the couplet the caret is in is centered, or null outside a
+ * two-column poetry block (centering only applies there). */
+export declare function $getCoupletCenteredFromSelection(): boolean | null;
+/** Centers (or un-centers) the caret's couplet within a two-column block by
+ * rebuilding its row around the same two misra paragraphs. */
+export declare function $setCoupletCentered(centered: boolean): boolean;
+/** Removes the whole poetry block the caret is in, including every couplet. */
+export declare function $deletePoetryBlock(): boolean;
+/** Single-column blocks pair their paragraphs into couplets, so a line left
+ * without a partner (from pasted or imported content) would be invisible to
+ * the couplet logic. Give it an empty partner instead, so every line belongs
+ * to a couplet and can be deleted like any other. */
+export declare function $completeSingleCoupletBlock(node: PoetryBlockNode): void;
+//# sourceMappingURL=poetryActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poetryActions.d.ts","sourceRoot":"","sources":["../../src/blocks/poetryActions.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAML,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,oDAAoD;AACpD,MAAM,MAAM,OAAO,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,EAAE,CAqB7D;AAED;;6CAE6C;AAC7C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,EAAE,CAE1E;AAED,oEAAoE;AACpE,wBAAgB,4BAA4B,IAAI,eAAe,GAAG,IAAI,CAKrE;AA0DD;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,CAevF;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAmBlF;AAED;;;;;;qDAMqD;AACrD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAEpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAiBlE;AAED;;;;wCAIwC;AACxC,wBAAgB,oBAAoB,IAAI,OAAO,CAwB9C;AAUD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAsClD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAkB9C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAgD5C;AAED;sDACsD;AACtD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAO1D;AAED;2BAC2B;AAC3B,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAOzD;AAED;iCACiC;AACjC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAO1D;AAYD;6DAC6D;AAC7D,wBAAgB,gCAAgC,IAAI,OAAO,GAAG,IAAI,CAUjE;AAED;8DAC8D;AAC9D,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAuB9D;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,OAAO,CAK5C;AAED;;;qDAGqD;AACrD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAGvE"}