@quillmark/svelte 0.5.1 → 0.6.0

package/dist/visual/diagnostics.d.ts

@@ -1,9 +1,9 @@
 import type { Diagnostic } from '@quillmark/wasm';
 /** A field's routing address, and `/core`'s `Addr` structurally: an `Addr` is a
- * positional `FieldKey`, so `addrForFieldPath` is the path→key walk and routing
- * carries no second copy of the grammar. `card` is `undefined` for the main card; a
- * composable card slot is a stable session id (the editor's own bookkeeping) once
- * resolved, or an absolute document-array index straight off a parsed `DocPath`
+ * positional `FieldKey`, so `nearestAddrForFieldPath` is the path→key walk and
+ * routing carries no second copy of the grammar. `card` is `undefined` for the main
+ * card; a composable card slot is a stable session id (the editor's own bookkeeping)
+ * once resolved, or an absolute document-array index straight off a parsed `DocPath`
  * (resolve via {@link resolveCardKey} before merging with id-keyed sources). `field`
  * `undefined` addresses the body (the field-less leaf). */
 export interface FieldKey {
@@ -29,13 +29,15 @@ export interface RoutedDiagnostic {
 }
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. Warnings do not draw (VISUAL_EDITOR
- * §Diagnostics): obligation, completeness, a render note — none of them is a value
- * the field cannot hold. An entry also drops rather than mis-routes when it carries
- * no `path`, when the path names no single commit address (a nested / array-element
- * one), or when its absolute card index is out of the live `cardIds`. Completeness
- * stays a read the host makes on `quill.validate(doc)`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export declare function routeAndResolve(diagnostics: Diagnostic[] | undefined, cardIds: readonly string[]): RoutedDiagnostic[];
 /**

package/dist/visual/diagnostics.js

@@ -1,4 +1,4 @@
-import { addrForFieldPath } from '../core/address.js';
+import { nearestAddrForFieldPath } from '../core/address.js';
 /** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
 export function fieldKeyToString(k) {
     return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
@@ -20,20 +20,22 @@ export function resolveCardKey(key, cardIds) {
 }
 /**
  * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
- * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
- * and `resolveCardKey` in a single pass. Warnings do not draw (VISUAL_EDITOR
- * §Diagnostics): obligation, completeness, a render note — none of them is a value
- * the field cannot hold. An entry also drops rather than mis-routes when it carries
- * no `path`, when the path names no single commit address (a nested / array-element
- * one), or when its absolute card index is out of the live `cardIds`. Completeness
- * stays a read the host makes on `quill.validate(doc)`.
+ * editor's stable-id keying: the one door producers #1/#3 take,
+ * `nearestAddrForFieldPath` and `resolveCardKey` in a single pass. Warnings do not
+ * draw (VISUAL_EDITOR §Diagnostics): obligation, completeness, a render note — none
+ * of them is a value the field cannot hold. An anchor deeper than a commit address
+ * (`main.contact.email`, `main.keywords[0]`) draws at the nearest field holding it,
+ * whose subform or repeater draws that leaf. An entry drops rather than mis-routes
+ * when it carries no `path`, when no prefix of the path is addressable, or when its
+ * absolute card index is out of the live `cardIds`.
+ * Completeness stays a read the host makes on `quill.validate(doc)`.
  */
 export function routeAndResolve(diagnostics, cardIds) {
     const out = [];
     for (const d of diagnostics ?? []) {
         if (d.severity !== 'error' || !d.path)
             continue;
-        const key = addrForFieldPath(d.path);
+        const key = nearestAddrForFieldPath(d.path);
         const resolved = key && resolveCardKey(key, cardIds);
         if (resolved)
             out.push({ key: resolved, diagnostic: d });

package/dist/visual/domid.d.ts

@@ -8,6 +8,19 @@ export interface FieldDomIds {
     description: string;
 }
 export declare function fieldDomIds(uid: string, leafKey: string): FieldDomIds;
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export declare function propertyDomIds(controlId: string, key: string): FieldDomIds;
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/domid.js

@@ -21,6 +21,22 @@ export function fieldDomIds(uid, leafKey) {
     const base = `qm-${uid}-${escapeId(leafKey)}`;
     return { control: base, label: `${base}-label`, description: `${base}-desc` };
 }
+/**
+ * A subform property's three names, derived from the field's own control id. A
+ * property is not a field — it has no leaf key, `Addr` reaching a root and one field
+ * and no deeper — so it borrows its parent's id space rather than minting a second:
+ * the same escape, one `-p-` segment down. That is what lets a property's label be a
+ * real `<label for>` like every other label on the surface, instead of a `<span>`
+ * folding its text into the control's composed name.
+ *
+ * The `-p-` infix cannot collide with a sibling field's id: an id is the escaped
+ * `card:field` and `-` only ever introduces an escape, so `-p-` decodes as nothing a
+ * key can spell.
+ */
+export function propertyDomIds(controlId, key) {
+    const base = `${controlId}-p-${escapeId(key)}`;
+    return { control: base, label: `${base}-label`, description: `${base}-desc` };
+}
 /**
  * A group panel's own id: what its header's `aria-controls` names, and the only
  * name in the DOM that is a card's rather than a field's. `card` follows the leaf

package/dist/visual/leaves.d.ts

@@ -10,15 +10,17 @@ import type { FieldController } from '../core/codec/index.js';
 export interface FieldControl {
     focus(): void;
     /**
-     * Focus element `index` of a control that has elements, resolving the index to the
-     * element's session id at the call; {@link focus}'s own answer for an index past
-     * the live list. Absent on every control without elements.
+     * Land in element `index` of a control that has elements, at USV `pos` where the
+     * row's control can take one; resolving the index to the element's session id at
+     * the call, with {@link focus}'s own answer for an index past the live list. Absent
+     * on every control without elements.
      *
-     * The granularity rides the call because the registry stays parent-keyed: a
-     * per-element key is positional, in a registry whose doctrine is dodging
-     * positional churn.
+     * A landing, not a focus: an absent `pos` is the placement rung, exactly as on
+     * `Landing`, and what a `pos` means is the row control's, the same way focusing is.
+     * The place rides the call because the registry stays parent-keyed: a per-element
+     * key is positional, in a registry whose doctrine is dodging positional churn.
      */
-    focusElement?(index: number): void;
+    focusElement?(index: number, pos?: number): void;
     readonly el: HTMLElement;
 }
 /**

package/dist/visual/links.d.ts

@@ -7,8 +7,11 @@ import type { Command, EditorState } from 'prosemirror-state';
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export declare function normalizeHref(raw: string): string;
 /**

package/dist/visual/links.js

@@ -1,3 +1,4 @@
+import { rendersHref } from '../core/codec/index.js';
 /** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 /** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
@@ -13,12 +14,17 @@ const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
  * userinfo — a wrong destination this normalization would itself have minted.
  *
  * A rooted value is left alone, being the spelling that asks for the embedding
- * page, and so is anything already carrying a scheme. `''` for a blank value, which
- * is nothing to apply.
+ * page, and so is anything already carrying a scheme the link mark renders.
+ *
+ * `''` for a blank value and for a scheme the mark renders inert, both being nothing
+ * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
+ * own exit rather than storing a link that draws as plain text.
  */
 export function normalizeHref(raw) {
     const value = raw.trim();
-    if (!value || SCHEME.test(value) || ROOTED.test(value))
+    if (!value || !rendersHref(value))
+        return '';
+    if (SCHEME.test(value) || ROOTED.test(value))
         return value;
     return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
 }

package/dist/visual/strings.d.ts

@@ -21,6 +21,21 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
+    /** The tag on the unset sentinel's row, which is what tells it from the member it
+     *  ghosts ({@link EnumField}). */
+    enumUnsetTag: string;
+    /**
+     * What stands where a subform declines to recurse (a nested prose / array /
+     * object property), and where to edit that property instead. The whole sentence,
+     * since a translator orders the kind within it.
+     */
+    nestedUnsupported: (kind: string) => string;
+    /**
+     * A collapsed array element whose first text property is empty: the label and the
+     * 1-based index, which is what its accessible name already says. Parametric, so
+     * word order stays the translator's.
+     */
+    elementUntitled: (label: string, index: number) => string;
     /** The required marker's accessible name; the glyph itself is a `*`. */
     fieldRequired: string;
     formatGroup: string;

package/dist/visual/strings.js

@@ -30,6 +30,9 @@ export const DEFAULT_VISUAL_STRINGS = {
     addCard: '+ Add Card',
     arrayAdd: '+ Add',
     arrayRemove: 'Remove',
+    enumUnsetTag: 'default',
+    nestedUnsupported: (kind) => `A nested ${kind} — edit this field in the source view.`,
+    elementUntitled: (label, index) => `${label} ${index}`,
     fieldRequired: 'required',
     formatGroup: 'Formatting',
     formatBold: 'Bold (Mod-B)',

package/dist/visual/structure.d.ts

@@ -1,6 +1,6 @@
 import type { QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
-export type ControlKind = 'prose' | 'text' | 'enum' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object';
 /** One field, projected: its schema, the control it renders as, and its layout hints. */
 export interface FieldModel {
     name: string;
@@ -17,11 +17,10 @@ export interface FieldModel {
      * undefined when the field declares none. Chrome-only; never gates. */
     description: string | undefined;
     /**
-     * Required-ness: the schema's `must_fill` obligation, which derives from
-     * `default:`'s absence when the field declares none (DOCUMENT_MODEL). Drives a
-     * persistent label `*`; a field can carry both it and a ghosted `default:`,
-     * since the two axes are independent. Persistent (schema-derived, survives
-     * filling). Label chrome only; never gates.
+     * Required-ness: {@link obliged}. Drives a persistent label `*`; a field never
+     * carries both it and a ghosted `default:`, that default being the whole of what
+     * retires the obligation. Persistent (schema-derived, survives filling). Label
+     * chrome only; never gates.
      */
     required: boolean;
     /** Prose-leaf flags (only meaningful when `control === 'prose'` / array items). */
@@ -149,6 +148,33 @@ export declare function resolveBodyGhost(resolvedDefault: string | undefined, cu
  * An array's element control is this over `items`: a missing `items` is a text
  * element. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
+/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export declare const VARIANT_DISCRIMINANT = "value";
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export declare function variantMember(value: Record<string, unknown> | undefined, ghostMember: string | undefined): string | undefined;
+/** The cells a member declares, or `undefined` where that world has none. */
+export declare function variantCells(schema: QuillFieldSchema, member: string | undefined): Record<string, QuillFieldSchema> | undefined;
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `undefined`.
+ */
+export declare function commitDiscriminant(value: Record<string, unknown> | undefined, member: string | undefined): Record<string, unknown> | undefined;
+/**
+ * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
+ * obligation (DOCUMENT_MODEL). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export declare function obliged(schema: QuillFieldSchema): boolean;
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export declare function humanize(name: string): string;
 /** Project a card schema's `fields` map (declaration = key order) into models. */

package/dist/visual/structure.js

@@ -55,7 +55,9 @@ export function controlKind(f) {
         case 'plaintext':
             return 'prose';
         case 'enum':
-            return 'enum';
+            // `variants:` is the one key that changes a field's resting shape (canon
+            // `SCHEMAS.md`): with it the field rests as a container, without it a bare string.
+            return f.variants ? 'variant' : 'enum';
         case 'string':
             return 'text';
         case 'number':
@@ -74,6 +76,46 @@ export function controlKind(f) {
             return 'text';
     }
 }
+/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
+ *  which the boundary does not export). Reserved: no variant may declare it. */
+export const VARIANT_DISCRIMINANT = 'value';
+/**
+ * Which world's cells to draw: the authored discriminant when the container carries
+ * one, else the ghosted default's member — an unset field renders its `default:`, so a
+ * defaulted world whose cells were hidden would print answers the form never asked
+ * for. The blank owns no world, and neither does a member declaring no cells.
+ */
+export function variantMember(value, ghostMember) {
+    const authored = value?.[VARIANT_DISCRIMINANT];
+    return (typeof authored === 'string' ? authored : ghostMember) || undefined;
+}
+/** The cells a member declares, or `undefined` where that world has none. */
+export function variantCells(schema, member) {
+    return member ? schema.variants?.[member] : undefined;
+}
+/**
+ * The container a discriminant pick commits, and the discriminant cell alone the unset
+ * sentinel clears: sibling cells are **kept** either way, since the boundary carries an
+ * answer its world does not select rather than dropping it (VISUAL_EDITOR §"Enum
+ * variants"). A container left holding nothing is an unset field, which commits
+ * `undefined`.
+ */
+export function commitDiscriminant(value, member) {
+    const next = { ...(value ?? {}) };
+    if (member !== undefined)
+        return { ...next, [VARIANT_DISCRIMINANT]: member };
+    delete next[VARIANT_DISCRIMINANT];
+    return Object.keys(next).length ? next : undefined;
+}
+/**
+ * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
+ * obligation (DOCUMENT_MODEL). A typed dictionary is exempt — a namespace declares no
+ * `default:` at all, and `validate` anchors obligation on the leaves under it, so
+ * reading one off the container would mark every subform required.
+ */
+export function obliged(schema) {
+    return schema.type !== 'object' && schema.default === undefined;
+}
 /** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
 export function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
@@ -89,7 +131,7 @@ export function fieldModels(cardSchema) {
         compact: !!schema.ui?.compact,
         label: schema.ui?.title ?? humanize(name),
         description: schema.description,
-        required: schema.must_fill ?? schema.default === undefined,
+        required: obliged(schema),
         inline: !!schema.inline,
         plaintext: schema.type === 'plaintext'
     }));
@@ -174,6 +216,10 @@ export function initialExpandedGroup(sections) {
  * document carries. Any of them stands its neighbour in a column of whitespace. An
  * inline prose leaf is one line tall and packs like any scalar.
  *
+ * A variant declines for the same reason one step further in: its height is the live
+ * world's cell count, so it is set by a pick rather than only by the document, and a
+ * packed neighbour would reflow every time the discriminant moves.
+ *
  * An array declines whatever its items are: one-line elements make a one-line step,
  * but nothing holds two arrays to the same number of them, so the shorter of a packed
  * pair pays a cell of whitespace for every element the taller one has past it, and
@@ -182,7 +228,7 @@ export function initialExpandedGroup(sections) {
 function packable(f) {
     if (!f.compact)
         return false;
-    if (f.control === 'object' || f.control === 'array')
+    if (f.control === 'object' || f.control === 'array' || f.control === 'variant')
         return false;
     return f.control !== 'prose' || f.inline;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.5.1",
+	"version": "0.6.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.105.0-0",
+		"@quillmark/wasm": ">=0.108.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {

package/dist/core/codec/clipboard.d.ts

@@ -1,59 +0,0 @@
-import { DOMParser as PMDOMParser, Slice } from 'prosemirror-model';
-import type { Node as PMNode, Schema } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
-import type { TableCell, TableProps } from '@quillmark/wasm';
-import { type TableAlign } from './table.js';
-/** What a clipboard event hands over, which is all either arm needs of it: jsdom has no
- *  `DataTransfer`, and the suite drives these paths with the two methods themselves. */
-interface Clipboard {
-    getData: (type: string) => string;
-    setData: (type: string, data: string) => void;
-}
-/**
- * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
- * rectangle, so a table with one arrives with the rows below it short and
- * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
- * covers, so the columns after it keep their index.
- *
- * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
- * reader is about to flatten, not to a rank of this one.
- */
-export declare function tableFromDOM(dom: Element): TableProps;
-/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
- *  one: a clipboard holding a table among other blocks is a document paste, and only a
- *  surface that takes nothing but a table (a cell) reads it this way. */
-export declare function tableFromClipboard(data: Clipboard | null | undefined): TableProps | undefined;
-/**
- * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
- * a `<th>` row whatever row of the source it came from, that being the row index 0 a
- * paste lands it at.
- */
-export declare function tableToDOM(block: TableCell[][], aligns: TableAlign[], owner: Document): Element;
-/**
- * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
- * table and what markdown carries. The delimiter follows the first row for the reason
- * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
- */
-export declare function tableToPipe(block: TableCell[][], aligns: TableAlign[]): string;
-/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
- *  over a selection its own surface holds, so the rectangle arrives already cut out and
- *  claiming the event is the caller's. */
-export declare function writeRectangle(data: Clipboard, block: TableCell[][], aligns: TableAlign[], owner: Document): void;
-/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
- *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
- *  through to the enclosing block. */
-export declare function tableClipboardParser(schema: Schema): PMDOMParser;
-/** Mint an id for every island a paste is carrying. An id is part of the document's
- *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
- *  pasted island with none reaches the store as an insert nothing can name afterwards.
- *  One minter for the whole slice, or a paste placing two tables hands them one id. */
-export declare function stampIslandIds(slice: Slice, doc: PMNode): Slice;
-/**
- * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
- * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
- * because what a `<table>` in the DOM means is a question only the clipboard asks — the
- * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
- * where an island is already a node and a `<table>` is the chrome drawing one.
- */
-export declare function tableClipboardPlugin(schema: Schema): Plugin;
-export {};

package/dist/core/codec/clipboard.js

@@ -1,202 +0,0 @@
-// The table island's clipboard door, both directions: what a copy writes, a paste
-// reads. The design and the two wire formats are CODEC §"The table island" and
-// §"Markdown at the edges"; what is here is the grammar.
-//
-// What crosses is A rectangle, never a cell. A `<table>` read in is one; the held cell
-// selection written out is one; a rectangle overlaid onto a table at a cell is one. The
-// wire therefore carries `TableCell[][]` and no coordinates: each end names its own
-// corner.
-//
-// A row 0 is A header, on both sides, which is the model's own rule (`table.ts`
-// §`allRows`): whichever row holds index 0 is the header. So a `<table>` with no `<th>`
-// promotes its first row, and a copied rectangle's first row is the header of what it
-// pastes.
-import { DOMParser as PMDOMParser, DOMSerializer, Fragment, Slice } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
-import { islandMinter } from './islands.js';
-import { inlineSchema } from './schema.js';
-import { ALIGNS, cellContent, cellFromDoc, emptyCell, normalizeTable } from './table.js';
-import { decode } from './decode.js';
-/** The two keys, spelled once: a reader and a writer that disagreed about which holds
- *  the table would each work alone and never round-trip. */
-const HTML = 'text/html';
-const PLAIN = 'text/plain';
-// ── Reading a table in ──────────────────────────────────────────────────────
-/**
- * One cell from its `<td>` / `<th>`. The inline schema is the whole normalization: it
- * declares one paragraph, no containers and no islands, so a cell holding blocks
- * flattens to its text and an image in one drops out rather than leaving a slot char
- * behind. Whitespace collapses and the ends trim, which is PM's own parse.
- */
-function cellFromDOM(dom) {
-    const para = PMDOMParser.fromSchema(inlineSchema).parse(dom, {
-        topNode: inlineSchema.nodes.paragraph.create()
-    });
-    return cellFromDoc(inlineSchema.nodes.doc.create(null, para), emptyCell());
-}
-/** A column's alignment off its header cell, which is where a pipe table's delimiter
- *  row puts it. Anything else (`start`, `justify`, absent) is `none`. */
-function alignFromDOM(dom) {
-    const raw = (dom.getAttribute('align') ??
-        dom.style?.textAlign ??
-        '').toLowerCase();
-    return ALIGNS.includes(raw) ? raw : 'none';
-}
-/**
- * A `<table>` element as props. `rowspan` is not carried — a merged cell is not a
- * rectangle, so a table with one arrives with the rows below it short and
- * {@link normalizeTable} pads them at the end. `colspan` is, as the empty cells it
- * covers, so the columns after it keep their index.
- *
- * Only the table's own rows: a `<tr>` inside a nested table belongs to a cell this
- * reader is about to flatten, not to a rank of this one.
- */
-export function tableFromDOM(dom) {
-    const rows = [];
-    const aligns = [];
-    for (const tr of dom.querySelectorAll('tr')) {
-        if (tr.closest('table') !== dom)
-            continue;
-        const cells = [];
-        for (const box of tr.children) {
-            if (box.tagName !== 'TD' && box.tagName !== 'TH')
-                continue;
-            if (!rows.length)
-                aligns.push(alignFromDOM(box));
-            cells.push(cellFromDOM(box));
-            const span = Number(box.getAttribute('colspan')) || 1;
-            for (let i = 1; i < span; i++) {
-                if (!rows.length)
-                    aligns.push('none');
-                cells.push(emptyCell());
-            }
-        }
-        rows.push(cells);
-    }
-    const [header = [], ...body] = rows;
-    return normalizeTable({ header, rows: body, aligns });
-}
-/** The table a paste is carrying, or `undefined` for a paste that holds none. The first
- *  one: a clipboard holding a table among other blocks is a document paste, and only a
- *  surface that takes nothing but a table (a cell) reads it this way. */
-export function tableFromClipboard(data) {
-    const html = data?.getData(HTML);
-    if (!html || !/<table[\s>]/i.test(html))
-        return undefined;
-    const dom = new DOMParser().parseFromString(html, HTML).querySelector('table');
-    return dom ? tableFromDOM(dom) : undefined;
-}
-// ── Writing a rectangle out ─────────────────────────────────────────────────
-/** A cell's inline DOM, serialized by the schema that declares its marks, which is what
- *  makes {@link cellFromDOM} its exact inverse. */
-function cellToDOM(cell, owner) {
-    const doc = decode(cellContent(cell), inlineSchema);
-    const line = doc.firstChild;
-    return DOMSerializer.fromSchema(inlineSchema).serializeFragment(line ? line.content : Fragment.empty, { document: owner });
-}
-/**
- * A rectangle as a `<table>`: the wire the HTML arm writes and reads. Its first row is
- * a `<th>` row whatever row of the source it came from, that being the row index 0 a
- * paste lands it at.
- */
-export function tableToDOM(block, aligns, owner) {
-    const table = owner.createElement('table');
-    block.forEach((cells, r) => {
-        const tr = owner.createElement('tr');
-        cells.forEach((cell, c) => {
-            const box = owner.createElement(r === 0 ? 'th' : 'td');
-            const align = aligns[c] ?? 'none';
-            if (align !== 'none')
-                box.style.textAlign = align;
-            box.appendChild(cellToDOM(cell, owner));
-            tr.appendChild(box);
-        });
-        table.appendChild(tr);
-    });
-    return table;
-}
-/** A cell's text as one pipe-table field: the delimiter escaped, since a `|` inside a
- *  cell would otherwise open a column that is not there. Marks are dropped, markdown
- *  being the lossy arm. */
-const pipeCell = (cell) => cell.text.replaceAll('|', '\\|');
-/**
- * A rectangle as pipe rows, delimiter row included: what a plain-text target reads as a
- * table and what markdown carries. The delimiter follows the first row for the reason
- * that row serializes as `<th>` — a pasted rectangle's row 0 is a header.
- */
-export function tableToPipe(block, aligns) {
-    const width = block[0]?.length ?? 0;
-    const rule = Array.from({ length: width }, (_, c) => {
-        const align = aligns[c] ?? 'none';
-        if (align === 'center')
-            return ':---:';
-        return align === 'left' ? ':---' : align === 'right' ? '---:' : '---';
-    });
-    const line = (cells) => `| ${cells.join(' | ')} |`;
-    const [head = [], ...body] = block;
-    return [line(head.map(pipeCell)), line(rule), ...body.map((row) => line(row.map(pipeCell)))].join('\n');
-}
-/** Put a rectangle on the clipboard, both arms. The caller is a `copy` / `cut` handler
- *  over a selection its own surface holds, so the rectangle arrives already cut out and
- *  claiming the event is the caller's. */
-export function writeRectangle(data, block, aligns, owner) {
-    data.setData(HTML, tableToDOM(block, aligns, owner).outerHTML);
-    data.setData(PLAIN, tableToPipe(block, aligns));
-}
-// ── The paste door ──────────────────────────────────────────────────────────
-/** The `<table>` rule: a clipboard table becomes the island the model already holds
- *  rather than the paragraph its text flattens to. `id` is left empty for
- *  {@link stampIslandIds}, a parse rule having no document to mint against. `loss` is
- *  authored: what this reader produces is a pipe table, so markdown carries it whole. */
-function tableParseRule() {
-    return {
-        tag: 'table',
-        node: 'island_block',
-        getAttrs: (dom) => ({
-            id: '',
-            islandType: 'table',
-            props: tableFromDOM(dom),
-            loss: 'lossless'
-        })
-    };
-}
-/** The clipboard's parser: the schema's own rules with the table rule ahead of them.
- *  Ahead, because a `<table>` otherwise matches nothing and its cells' text falls
- *  through to the enclosing block. */
-export function tableClipboardParser(schema) {
-    return new PMDOMParser(schema, [tableParseRule(), ...PMDOMParser.fromSchema(schema).rules]);
-}
-/** An island node a parse rule produced, which is the only kind carrying no id. */
-const unstamped = (node) => (node.type.name === 'island_block' || node.type.name === 'island_inline') && !node.attrs.id;
-/** Mint an id for every island a paste is carrying. An id is part of the document's
- *  canonical bytes and the channel that addresses an island (CODEC §Islands), so a
- *  pasted island with none reaches the store as an insert nothing can name afterwards.
- *  One minter for the whole slice, or a paste placing two tables hands them one id. */
-export function stampIslandIds(slice, doc) {
-    const mint = islandMinter(doc);
-    const walk = (fragment) => {
-        const out = [];
-        fragment.forEach((node) => {
-            const next = node.content.size ? node.copy(walk(node.content)) : node;
-            out.push(unstamped(next) ? next.type.create({ ...next.attrs, id: mint() }, next.content) : next);
-        });
-        return Fragment.fromArray(out);
-    };
-    return new Slice(walk(slice.content), slice.openStart, slice.openEnd);
-}
-/**
- * The block leaf's clipboard plugin: the table rule on the way in, and the id mint over
- * what it produced. A `clipboardParser` rather than the schema's own `parseDOM`,
- * because what a `<table>` in the DOM means is a question only the clipboard asks — the
- * schema's parse rules are also what a re-parse of the editor's own DOM runs through,
- * where an island is already a node and a `<table>` is the chrome drawing one.
- */
-export function tableClipboardPlugin(schema) {
-    const parser = tableClipboardParser(schema);
-    return new Plugin({
-        props: {
-            clipboardParser: parser,
-            transformPasted: (slice, view) => stampIslandIds(slice, view.state.doc)
-        }
-    });
-}