quill-clausula 0.1.0

package/README.md

@@ -0,0 +1,133 @@
+# quill-clausula
+
+Brazilian legal document formatting module for [Quill 2](https://quilljs.com) — auto-numbered **Cláusulas**, **Parágrafos**, **Incisos**, and **Alíneas**, plus contract **Partes** (CONTRATANTE/CONTRATADO), **OBJETO**, signature blocks, and per-clause Lock / Agree / Disagree workflow.
+
+Also ships:
+
+- **Markdown import** (`importMarkdown`) — AI-generated legal Markdown → Delta with live clause numbering
+- **Markdown/HTML export** (`exportMarkdown` / `exportHTML`) — numbering labels materialized; MD is pandoc-friendly for DOCX pipelines
+- **Ghost Cut** — non-destructive Ctrl+X ([Textualize's idea](https://ishmael.textualize.io/blog/ghost-cut/)): the selection fades instead of being deleted; Ctrl+V moves it atomically (single undo); Esc cancels
+- **Clause organizer** — floating drag handle to reorder whole clause blocks (parent + children)
+- **Word-style spacing** — `lineheight` and `spacing` (space-after) block formats
+- Table export support (Quill 2's table module → pipe tables in MD, `<table>` in HTML)
+
+## Installation
+
+```sh
+npm install quill-clausula quill
+```
+
+## Quick Start
+
+```js
+import Quill from 'quill';
+import { register } from 'quill-clausula';
+import 'quill-clausula/dist/quill-clausula.css';
+import 'quill/dist/quill.snow.css';
+
+register();
+
+const quill = new Quill('#editor', {
+  theme: 'snow',
+  modules: {
+    toolbar: {
+      container: [
+        [
+          { clausula: ['clausula', 'subclausula', 'paragrafo', 'inciso', 'alinea', false] },
+          { parte: ['contratante', 'contratado', false] },
+        ],
+        ['objeto', 'assinatura'],
+        ['bold', 'italic', 'underline'],
+      ],
+    },
+    clausula: {
+      clausulaFormat: 'extenso',      // CLÁUSULA PRIMEIRA —
+      paragrafoFormat: 'extenso',     // Parágrafo Primeiro. / Parágrafo Único.
+      incisoFormat: 'roman',          // I —, II —
+      alineaFormat: 'letter-parenthesis', // a), b)
+      currentUser: 'user1',
+      users: ['user1', 'user2'],
+    },
+  },
+});
+```
+
+## Autofill
+
+Type a trigger word at the start of a line followed by Space:
+
+| Trigger | Result |
+|---|---|
+| `cl`, `clausula` | Cláusula |
+| `sub`, `subclausula` | Sub-cláusula |
+| `par`, `paragrafo`, `§` | Parágrafo |
+| `inc`, `inciso` | Inciso |
+| `al`, `alinea` | Alínea |
+| `contratante`, `contratado` | Parte (with template) |
+| `objeto` | Objeto |
+
+Tab / Shift+Tab promote and demote clause levels.
+
+## Numbering formats
+
+- `clausulaFormat`: `extenso`, `numeric`, `numeric-padded`, `ordinal`, `abbreviation`, `regular`, `regular-padded`
+- `subclausulaFormat`: `dotted` (1.1), `dotted-padded`, `numeric`, `extenso`
+- `paragrafoFormat`: `extenso`, `uppercase`, `numeric`, `symbol` (§1º) — a single parágrafo renders as *Parágrafo Único*
+- `incisoFormat`: `roman`, `roman-lower`
+- `alineaFormat`: `letter-parenthesis`, `letter`
+
+Change `module.options` at runtime and call `module.renumber()` to reformat.
+
+## Import / Export
+
+```js
+import { importMarkdown, exportMarkdown, exportHTML } from 'quill-clausula';
+
+// AI-generated legal Markdown -> Delta with clausula attributes
+quill.setContents(importMarkdown(aiMarkdown));
+
+// Delta -> pandoc-friendly Markdown / clean HTML (numbering materialized)
+const module = quill.getModule('clausula');
+const md = module.exportMarkdown();   // pipe into `pandoc -o contrato.docx`
+const html = module.exportHTML();     // print / PDF / read-only display
+```
+
+`importMarkdown` recognizes the patterns LLMs produce for Brazilian legal
+documents (`## CLÁUSULA PRIMEIRA — ...`, `1.1`, `§1º`, `Parágrafo Único.`,
+`I —`, `a)`, `CONTRATANTE:`, `OBJETO:`) and STRIPS the numbering labels — the
+module re-materializes them, so numbering never goes stale in the editor.
+
+## Persistence
+
+Save and restore documents with **deltas only** (`quill.getContents()` / `quill.setContents()`).
+
+> **Warning:** numbering labels ("CLÁUSULA PRIMEIRA — ", "1.1", "§1º") are presentation-only UI nodes. `quill.getSemanticHTML()` omits them, and saving `root.innerHTML` duplicates them on reload. For print/PDF HTML with numbering use `exportHTML()`; for DOCX use `exportMarkdown()` + pandoc.
+
+## Editing UX
+
+- **Ghost Cut**: Ctrl+X fades the selection (nothing is deleted, clipboard untouched, no undo entry); Ctrl+V moves it to the cursor as ONE undoable operation; Esc cancels. Full-line cuts carry the line format, so cutting a cláusula never leaves an orphaned number. Traditional cut = Ctrl+C + Backspace.
+- **Clause organizer**: hover a cláusula and a ⋮⋮ handle appears on the left; drag it to move the whole block (cláusula + children) — numbering follows.
+- **Tab / Shift+Tab** promote and demote clause levels; `destroy()` detaches everything for SPA unmounting.
+
+## Options
+
+| Option | Default | Description |
+|---|---|---|
+| `currentUser` | — | User id recording agree/disagree votes |
+| `users` | — | All users that must agree before Sign enables |
+| `showActions` | `true` | Per-clause Lock/Agree/Disagree/Conversation buttons |
+| `showFloatingBar` | `true` | Global action bar (Agree All, Lock All, Sign…) |
+| `showDragHandle` | `true` | Floating drag handle to reorder clause blocks |
+| `onJudge` / `onShare` / `onSign` / `onConversation` | — | Callbacks for the corresponding buttons |
+
+## Development
+
+```sh
+npm run dev    # demo at localhost:5173
+npm test       # vitest
+npm run build  # dist/ (esm + cjs + css + types)
+```
+
+## License
+
+MIT

package/dist/actions/action-buttons.d.ts

@@ -0,0 +1,2 @@
+export declare function createActionButtons(doc: Document): HTMLDivElement;
+export declare function syncButtonState(actionsContainer: HTMLElement, domNode: HTMLElement, currentUser: string | undefined, users: string[] | undefined, children?: HTMLElement[]): void;

package/dist/actions/drag-organizer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Clause organizer — a floating drag handle (⋮⋮) that appears to the left of
+ * the cláusula under the mouse. Dragging it moves the WHOLE clause block
+ * (parent cláusula + its children) to another position; a drop indicator
+ * line shows the target boundary while dragging.
+ *
+ * The handle is an overlay on `quill.container` (never inside the editable
+ * DOM), so Quill's document model is untouched until the actual move, which
+ * the module performs as a single atomic delta.
+ */
+export interface DragBlock {
+    /** Clausula item blots: parent first, then its children */
+    items: any[];
+}
+export interface DragOrganizerCallbacks {
+    getBlocks: () => DragBlock[];
+    /** Move block `sourceIndex` to sit at boundary `targetBoundary` (0..blocks.length) */
+    moveBlock: (sourceIndex: number, targetBoundary: number) => void;
+}
+export declare class DragOrganizer {
+    private quill;
+    private callbacks;
+    private container;
+    private handle;
+    private indicator;
+    private hoveredBlockIndex;
+    private hoveredParentEl;
+    private hideTimer;
+    private dragging;
+    private dropBoundary;
+    private blockRects;
+    private onMouseMove;
+    private onMouseLeave;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    constructor(quill: any, callbacks: DragOrganizerCallbacks);
+    private hideHandle;
+    /** Hide with a grace period so the mouse can travel to the handle. */
+    private scheduleHide;
+    private cancelHide;
+    /**
+     * While a block is hovered, the strip from the handle to the block's
+     * right edge (with vertical slack) counts as "still hovering" — without
+     * it the handle vanishes as soon as the mouse leaves the text on its
+     * way to grab it.
+     */
+    private isInReachCorridor;
+    private trackHover;
+    private startDrag;
+    private trackDrag;
+    private endDrag;
+    destroy(): void;
+}

package/dist/actions/floating-bar.d.ts

@@ -0,0 +1,19 @@
+export interface FloatingBarCallbacks {
+    onUndo?: () => void;
+    onAgreeAll?: () => void;
+    onDisagreeAll?: () => void;
+    onLockAll?: () => void;
+    onJudge?: () => void;
+    onShare?: () => void;
+    onSign?: () => void;
+}
+export declare function createFloatingBar(doc: Document, callbacks: FloatingBarCallbacks): HTMLDivElement;
+/**
+ * Creates the undo warning modal overlay.
+ */
+export declare function createUndoModal(doc: Document, onConfirm: () => void, onCancel: () => void): HTMLDivElement;
+/**
+ * Check if all clausula items (leaf-level, non-parent) have all users agreed.
+ * Returns true only when every leaf item has `agreed[user] === true` for every user.
+ */
+export declare function isContractFullyAgreed(allItems: HTMLElement[], users: string[]): boolean;

package/dist/actions/ghost-cut.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Ghost Cut — a non-destructive cut, after Textualize's "ghost cut" idea
+ * (https://ishmael.textualize.io/blog/ghost-cut/):
+ *
+ * - **Ctrl+X / Cmd+X (or menu Cut)**: nothing is deleted and nothing touches
+ *   the clipboard. The selection just fades — it becomes "ghost" content.
+ *   No undo entry is created.
+ * - **Ctrl+V / Cmd+V**: the ghost content is moved to the cursor in ONE
+ *   atomic delta — a single undo restores everything.
+ * - **Escape**: the ghost returns to normal, nothing changed.
+ * - A traditional destructive cut is still available as Ctrl+C + Backspace.
+ *
+ * When the selection covers whole line(s), the range is extended to include
+ * the trailing newline so line formats (clausula, parte, objeto) travel with
+ * the move — cutting a cláusula never leaves an orphaned numbered line
+ * behind.
+ */
+interface GhostRange {
+    index: number;
+    length: number;
+}
+/** Scans a delta for the contiguous extent of `ghost` formatted content. */
+export declare function findGhostRange(delta: {
+    ops: any[];
+}): GhostRange | null;
+export declare class GhostCut {
+    private quill;
+    private isRangeLocked;
+    constructor(quill: any, options: {
+        isRangeLocked: (index: number, length: number) => boolean;
+    });
+    get active(): boolean;
+    private findRange;
+    /**
+     * Expands a selection to include the trailing newline when it covers the
+     * entire text of its line(s), so line formats move together.
+     */
+    private expandToLineBoundary;
+    /** Handles a `cut` DOM event. Returns true when the event was consumed. */
+    handleCut(event: ClipboardEvent): boolean;
+    /**
+     * Lines fully covered by the ghost range get a line-level class so their
+     * UI labels ("CLÁUSULA SEGUNDA — ", "2.1", "Parágrafo Primeiro.") fade
+     * together with the content — the label is presentation DOM, not text,
+     * so the inline ghost format alone cannot reach it.
+     */
+    private markGhostLines;
+    private clearGhostLines;
+    /** Handles a `paste` DOM event. Returns true when the event was consumed. */
+    handlePaste(event: ClipboardEvent): boolean;
+    /** Cancels an active ghost (Escape). Returns true when one was cleared. */
+    cancel(): boolean;
+    destroy(): void;
+}
+export {};

package/dist/actions/move-delta.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Builds the op list for an atomic "move" delta: remove `length` characters
+ * at `start` and re-insert them (as `sliceOps`) at `target`, where `target`
+ * is a position in the PRE-move document. The result applies as a single
+ * updateContents call — one history entry, fully undoable.
+ */
+export declare function buildMoveOps(start: number, length: number, target: number, sliceOps: Array<Record<string, unknown>>): Array<Record<string, unknown>>;

package/dist/assinatura/assinatura-renderer.d.ts

@@ -0,0 +1,5 @@
+import type { AssinaturaConfig, SignatureLine } from '../types.js';
+/**
+ * Renders the signature block HTML from extracted names + config.
+ */
+export declare function renderAssinatura(lines: SignatureLine[], config: AssinaturaConfig): string;

package/dist/assinatura/assinatura-sync.d.ts

@@ -0,0 +1,12 @@
+import type { SignatureLine } from '../types.js';
+interface ParteBlotLike {
+    domNode: HTMLElement;
+}
+/**
+ * Extracts signature lines from parte blots.
+ *
+ * For each parte, the "name" is the text content before the first comma.
+ * If no comma is found, the entire text content is used.
+ */
+export declare function extractSignatureLines(parteItems: ParteBlotLike[]): SignatureLine[];
+export {};

package/dist/autofill.d.ts

@@ -0,0 +1,22 @@
+import type { ClausulaType } from './types.js';
+/**
+ * Extra triggers for non-clausula formats (parte, objeto).
+ * Returns { format, value } for applying to the line.
+ */
+export interface ExtraTriggerResult {
+    format: string;
+    value: string;
+}
+/**
+ * The full regex that matches any trigger word at the start of a line.
+ * Used as the `prefix` in the keyboard binding.
+ */
+export declare const AUTOFILL_PREFIX: RegExp;
+/**
+ * Given a matched prefix string, return the corresponding clausula type.
+ */
+export declare function matchTrigger(prefix: string): ClausulaType | null;
+/**
+ * Given a matched prefix string, return a non-clausula format trigger if matched.
+ */
+export declare function matchExtraTrigger(prefix: string): ExtraTriggerResult | null;

package/dist/blots/assinatura-embed.d.ts

@@ -0,0 +1,11 @@
+import type { AssinaturaConfig } from '../types.js';
+declare const BlockEmbed: any;
+declare class AssinaturaEmbed extends BlockEmbed {
+    static blotName: string;
+    static tagName: "DIV";
+    static className: string;
+    static create(value: AssinaturaConfig | string): HTMLElement;
+    static value(domNode: HTMLElement): AssinaturaConfig;
+    static formats(domNode: HTMLElement): undefined;
+}
+export default AssinaturaEmbed;

package/dist/blots/clausula-container.d.ts

@@ -0,0 +1,4 @@
+declare const Container: any;
+declare class ClausulaContainer extends Container {
+}
+export default ClausulaContainer;

package/dist/blots/clausula-item.d.ts

@@ -0,0 +1,15 @@
+import type { ClausulaType } from '../types.js';
+declare const Block: any;
+declare class ClausulaItem extends Block {
+    static blotName: string;
+    static tagName: "DIV";
+    static className: string;
+    actionsNode: HTMLElement | null;
+    static create(value: ClausulaType): HTMLElement;
+    static formats(domNode: HTMLElement): string | undefined;
+    static register(): void;
+    constructor(scroll: any, domNode: HTMLElement);
+    format(name: string, value: string): void;
+    update(mutations: MutationRecord[], context: Record<string, any>): void;
+}
+export default ClausulaItem;

package/dist/blots/objeto-container.d.ts

@@ -0,0 +1,4 @@
+declare const Container: any;
+declare class ObjetoContainer extends Container {
+}
+export default ObjetoContainer;

package/dist/blots/objeto-item.d.ts

@@ -0,0 +1,12 @@
+declare const Block: any;
+declare class ObjetoItem extends Block {
+    static blotName: string;
+    static tagName: "DIV";
+    static className: string;
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): "true" | undefined;
+    static register(): void;
+    constructor(scroll: any, domNode: HTMLElement);
+    format(name: string, value: string): void;
+}
+export default ObjetoItem;

package/dist/blots/parte-container.d.ts

@@ -0,0 +1,4 @@
+declare const Container: any;
+declare class ParteContainer extends Container {
+}
+export default ParteContainer;

package/dist/blots/parte-item.d.ts

@@ -0,0 +1,13 @@
+import type { ParteType } from '../types.js';
+declare const Block: any;
+declare class ParteItem extends Block {
+    static blotName: string;
+    static tagName: "DIV";
+    static className: string;
+    static create(value: ParteType): HTMLElement;
+    static formats(domNode: HTMLElement): string | undefined;
+    static register(): void;
+    constructor(scroll: any, domNode: HTMLElement);
+    format(name: string, value: string): void;
+}
+export default ParteItem;

package/dist/export/exporter.d.ts

@@ -0,0 +1,64 @@
+import type { AssinaturaConfig, ClausulaModuleOptions, ClausulaType, ParteType } from '../types.js';
+/**
+ * Delta-based document export.
+ *
+ * The delta is the single source of truth for persistence; numbering labels
+ * ("CLÁUSULA PRIMEIRA — ", "1.1", "§1º") exist only as presentation-side UI
+ * nodes and are NOT part of the delta. These exporters re-materialize the
+ * labels from the delta's line attributes, producing output that carries the
+ * full legal numbering:
+ *
+ * - `exportMarkdown` → pandoc-friendly Markdown (e.g. for DOCX conversion)
+ * - `exportHTML`     → clean, class-annotated HTML (print / PDF / preview)
+ */
+interface DeltaOp {
+    insert?: string | Record<string, unknown>;
+    attributes?: Record<string, any>;
+}
+export interface DeltaLike {
+    ops: DeltaOp[];
+}
+export interface ExportSegment {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+}
+export interface ExportLine {
+    kind: 'clausula' | 'parte' | 'objeto' | 'assinatura' | 'table-cell' | 'text';
+    /** Row identifier when kind is 'table-cell' (cells of the same row share it) */
+    tableRow?: string;
+    clausulaType?: ClausulaType;
+    parteType?: ParteType;
+    /** Materialized numbering/prefix label ('' when not applicable) */
+    label: string;
+    /** Plain text content of the line */
+    text: string;
+    segments: ExportSegment[];
+    locked?: boolean;
+    agreed?: Record<string, boolean>;
+    assinatura?: AssinaturaConfig;
+    /** Word-style spacing (CSS values), when set on the line */
+    lineHeight?: string;
+    spacingAfter?: string;
+}
+/**
+ * Parses a delta into a flat list of logical lines with materialized
+ * numbering labels. This is the shared document model both exporters use.
+ */
+export declare function parseDeltaToLines(delta: DeltaLike, options: ClausulaModuleOptions): ExportLine[];
+/**
+ * Exports a delta as pandoc-friendly Markdown with all numbering labels
+ * materialized. Cláusulas become `##` headings (mapping to Heading 2 in
+ * DOCX); every other label is emitted as literal bold text so pandoc/word
+ * processors never renumber the legal structure.
+ */
+export declare function exportMarkdown(delta: DeltaLike, options: ClausulaModuleOptions): string;
+/**
+ * Exports a delta as clean, self-describing HTML with all numbering labels
+ * materialized — suitable for print, PDF generation, or read-only display
+ * outside the editor. (Unlike `quill.getSemanticHTML()`, which omits the
+ * labels, and `quill.root.innerHTML`, which duplicates them on reload.)
+ */
+export declare function exportHTML(delta: DeltaLike, options: ClausulaModuleOptions): string;
+export {};

package/dist/formats/agreed.d.ts

@@ -0,0 +1,9 @@
+declare const Attributor: any;
+declare class AgreedAttributor extends Attributor {
+    constructor(attrName: string, keyName: string, options?: Record<string, unknown>);
+    add(node: HTMLElement, value: Record<string, boolean> | string): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): Record<string, boolean> | undefined;
+}
+declare const Agreed: AgreedAttributor;
+export default Agreed;

package/dist/formats/ghost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Transient inline format used by Ghost Cut: text marked `ghost` is the
+ * faded, inert content awaiting a paste-to-move. It is applied and removed
+ * with SILENT source (no history entries) and never survives an export.
+ */
+declare const GhostAttribute: any;
+export default GhostAttribute;

package/dist/formats/locked.d.ts

@@ -0,0 +1,2 @@
+declare const LockedAttribute: any;
+export default LockedAttribute;

package/dist/formats/spacing.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Word-style spacing controls, stored in the delta as line attributes:
+ *
+ * - `lineheight`: line spacing within the paragraph (Word's "entre linhas")
+ * - `spacing`:    space after the paragraph (Word's "depois do parágrafo")
+ *
+ * Both are plain CSS style attributors, so they survive copy/paste and
+ * export naturally as inline styles.
+ */
+export declare const LINE_HEIGHTS: readonly ["1", "1.15", "1.5", "2", "2.5", "3"];
+export declare const PARAGRAPH_SPACINGS: readonly ["0em", "0.5em", "1em", "1.5em", "2em"];
+export declare const LineHeightAttribute: any;
+export declare const ParagraphSpacingAttribute: any;

package/dist/import/markdown-importer.d.ts

@@ -0,0 +1,37 @@
+import type { DeltaLike } from '../export/exporter.js';
+/**
+ * Markdown → Quill Delta importer.
+ *
+ * Converts AI-generated Brazilian legal documents (Markdown) into a Delta
+ * whose lines carry quill-clausula attributes (`clausula`, `parte`,
+ * `objeto`), with numbering labels STRIPPED — the module re-materializes
+ * them dynamically, so imported numbers never go stale when clauses are
+ * added, removed, or reordered in the editor.
+ *
+ * Recognized patterns (tolerant to the typical LLM output variance):
+ *
+ *   ## CLÁUSULA PRIMEIRA — DO OBJETO        → clausula (text: "DO OBJETO")
+ *   CLÁUSULA 2ª - DO PREÇO                  → clausula
+ *   **1.1** texto  /  1.1 texto  / 1.1. texto → subclausula
+ *   §1º texto / § 2º. texto                 → paragrafo
+ *   Parágrafo Único. texto / **Parágrafo Primeiro.** texto → paragrafo
+ *   I — texto / IV - texto                  → inciso
+ *   a) texto / b) texto                     → alinea
+ *   CONTRATANTE: texto / **CONTRATADA:** texto → parte
+ *   OBJETO: texto                           → objeto
+ *
+ * Inline `**bold**`, `*italic*` and `_italic_` are converted to Quill
+ * attributes. YAML frontmatter is dropped.
+ */
+interface InsertOp {
+    insert: string;
+    attributes?: Record<string, unknown>;
+}
+/** Minimal inline Markdown parser: **bold**, *italic*, _italic_. */
+export declare function parseInline(text: string): InsertOp[];
+/**
+ * Converts legal-document Markdown into a Quill Delta with quill-clausula
+ * line attributes. Feed the result to `quill.setContents(...)`.
+ */
+export declare function importMarkdown(markdown: string): DeltaLike;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import ClausulaModule from './module.js';
+import ClausulaItem from './blots/clausula-item.js';
+import ClausulaContainer from './blots/clausula-container.js';
+import ParteItem from './blots/parte-item.js';
+import ParteContainer from './blots/parte-container.js';
+import ObjetoItem from './blots/objeto-item.js';
+import ObjetoContainer from './blots/objeto-container.js';
+import AssinaturaEmbed from './blots/assinatura-embed.js';
+import LockedAttribute from './formats/locked.js';
+import AgreedAttribute from './formats/agreed.js';
+import GhostAttribute from './formats/ghost.js';
+import { LineHeightAttribute, ParagraphSpacingAttribute } from './formats/spacing.js';
+export declare function register(): void;
+export { createActionButtons, syncButtonState } from './actions/action-buttons.js';
+export { createFloatingBar, createUndoModal, isContractFullyAgreed } from './actions/floating-bar.js';
+export { ClausulaModule, ClausulaItem, ClausulaContainer, ParteItem, ParteContainer, ObjetoItem, ObjetoContainer, AssinaturaEmbed, LockedAttribute, AgreedAttribute, GhostAttribute, LineHeightAttribute, ParagraphSpacingAttribute, };
+export { LINE_HEIGHTS, PARAGRAPH_SPACINGS } from './formats/spacing.js';
+export type { ClausulaType, ClausulaFormat, SubclausulaFormat, ParagrafoFormat, IncisoFormat, AlineaFormat, ClausulaModuleOptions, ClausulaIndex, ConversationContext, ParteType, ParteIndex, AssinaturaConfig, SignatureLine, } from './types.js';
+export { toExtenso, toExtensoUpper } from './numbering/extenso.js';
+export { toRoman, toRomanLower } from './numbering/roman.js';
+export { computeIndices, computeIndicesFromTypes } from './numbering/counter.js';
+export { formatLabel } from './numbering/formatter.js';
+export { computeParteIndices, computeParteIndicesFromTypes, formatParteLabel } from './partes/partes-counter.js';
+export { extractSignatureLines } from './assinatura/assinatura-sync.js';
+export { renderAssinatura } from './assinatura/assinatura-renderer.js';
+export { matchTrigger, matchExtraTrigger, AUTOFILL_PREFIX } from './autofill.js';
+export { exportMarkdown, exportHTML, parseDeltaToLines } from './export/exporter.js';
+export type { ExportLine, ExportSegment, DeltaLike } from './export/exporter.js';
+export { importMarkdown, parseInline } from './import/markdown-importer.js';
+export { GhostCut, findGhostRange } from './actions/ghost-cut.js';
+export { DragOrganizer } from './actions/drag-organizer.js';
+export { buildMoveOps } from './actions/move-delta.js';