@quillmark/svelte 0.21.0 → 0.22.0

package/dist/core/codec/index.js

@@ -13,7 +13,7 @@ import './prose.css';
 // selection (`visual/FormatPopover.svelte`), so it is reached off-barrel.
 export { rangeAnchor } from './anchor.js';
 // The prose leaf.
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 // The table island's chrome vocabulary: the visual tier's `strings` set extends it,
 // so the island's wording is overridden beside every other key.
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
@@ -37,7 +37,7 @@ export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 // Reconciliation gate.
 export { createReconciler, contentEqual, valueEqual } from './reconcile.js';
-// Input rules (`createField` mounts them unless `noInputRules`/`plaintext`).
+// Input rules (`createField` mounts them unless `noInputRules`, or over a mark-free schema).
 export { inputRulesPlugin } from './inputrules.js';
 // The body leaf's structural keys: `createField` binds the composed chains
 // (`bodyKeymap`); the suite drives both it and the list link directly.

package/dist/core/codec/inputrules.js

@@ -58,7 +58,7 @@ export function markdownInputRules(schema) {
     const rules = [];
     const m = schema.marks;
     // Inline marks. Non-greedy capture between matching delimiters. Built only where the
-    // schema has the mark: the inline schema omits them, and a plaintext one declares none
+    // schema has the mark: the inline schema omits them, and a `text` one declares none
     // at all.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));

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

@@ -1,7 +1,7 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
 /**
- * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The list bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which declare no list nodes.
  *
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
@@ -13,7 +13,8 @@ import type { Command } from 'prosemirror-state';
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
  * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
+ * then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts

package/dist/core/codec/lists.js

@@ -1,6 +1,8 @@
-import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { liftListItem, sinkListItem } from 'prosemirror-schema-list';
 import { EditorState, Selection, TextSelection } from 'prosemirror-state';
 import { chainCommands, joinTextblockBackward, joinTextblockForward } from 'prosemirror-commands';
+import { withinNesting } from './nesting.js';
+import { splitTaskItem } from './tasks.js';
 /** The caret's enclosing `list_item` when it sits at the very start of that item's
  * first block: the position both structural keys branch on. `null` otherwise
  * (mid-text, a non-first block of a multi-paragraph item, a non-empty selection),
@@ -187,8 +189,21 @@ function backspaceBelow(itemType, press) {
         return press(EditorState.create({ doc: state.doc, selection: below }), dispatch && keepCaret);
     };
 }
+/** Tab → `sinkListItem`, declined where the sink would nest past `MAX_NESTING_DEPTH`
+ *  (`nesting.ts`), so Tab there leaves the body as it does on an item with nothing to
+ *  sink under. */
+function sinkWithin(itemType) {
+    const sink = sinkListItem(itemType);
+    return (state, dispatch) => {
+        let sunk;
+        if (!sink(state, (tr) => (sunk = tr)) || !sunk || !withinNesting(sunk.doc))
+            return false;
+        dispatch?.(sunk);
+        return true;
+    };
+}
 /**
- * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The list bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which declare no list nodes.
  *
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
@@ -200,7 +215,8 @@ function backspaceBelow(itemType, press) {
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
  * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
+ * then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
  * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts
@@ -217,9 +233,9 @@ export function listKeymap(schema) {
         return {};
     const backspace = chainCommands(liftAtItemStart(itemType), joinOntoList(itemType));
     return {
-        Tab: sinkListItem(itemType),
+        Tab: sinkWithin(itemType),
         'Shift-Tab': liftListItem(itemType),
-        Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitListItem(itemType), liftListItem(itemType)),
+        Enter: chainCommands(paragraphAboveList(itemType, paragraph), splitTaskItem(itemType), liftListItem(itemType)),
         Backspace: backspace,
         Delete: backspaceBelow(itemType, backspace)
     };

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

@@ -0,0 +1,20 @@
+import type { Node as PMNode } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** The store's bound on the containers around one line: a commit nesting past it is
+ *  refused, and `@quillmark/wasm` exports no constant to read it from. */
+export declare const MAX_NESTING_DEPTH = 12;
+/** The most containers any block in `doc` stands inside, counted as the store counts
+ *  them: a `list_item` or a `blockquote` is one, the list around an item none, and no
+ *  node holds an element (`decode.ts`). */
+export declare function nestingDepth(doc: PMNode): number;
+/** Whether `doc` nests within {@link MAX_NESTING_DEPTH}: what a command that nests asks
+ *  of the doc it would dispatch. */
+export declare function withinNesting(doc: PMNode): boolean;
+/**
+ * Refuses a transaction leaving `doc` past {@link MAX_NESTING_DEPTH}, which the commit
+ * would lose: a paste or a drop into a deep item, whose slice the import bounded alone.
+ * The nesting commands ask first and keep their key; this is what reaches the rest, and
+ * a refused paste lands nothing. Past the bound, a transaction passes where it leaves the
+ * deepest level no deeper, so a body that arrived that deep keeps its Enter.
+ */
+export declare function nestingPlugin(): Plugin;

package/dist/core/codec/nesting.js

@@ -0,0 +1,62 @@
+import { Plugin } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+/** The store's bound on the containers around one line: a commit nesting past it is
+ *  refused, and `@quillmark/wasm` exports no constant to read it from. */
+export const MAX_NESTING_DEPTH = 12;
+/** The most containers any block in `doc` stands inside, counted as the store counts
+ *  them: a `list_item` or a `blockquote` is one, the list around an item none, and no
+ *  node holds an element (`decode.ts`). */
+export function nestingDepth(doc) {
+    const walk = (node, depth) => {
+        let deepest = depth;
+        node.forEach((child) => {
+            if (child.isTextblock || child.isAtom)
+                return;
+            const name = child.type.name;
+            const d = depth + (name === 'list_item' || name === 'blockquote' ? 1 : 0);
+            deepest = Math.max(deepest, walk(child, d));
+        });
+        return deepest;
+    };
+    return walk(doc, 0);
+}
+/** Whether `doc` nests within {@link MAX_NESTING_DEPTH}: what a command that nests asks
+ *  of the doc it would dispatch. */
+export function withinNesting(doc) {
+    return nestingDepth(doc) <= MAX_NESTING_DEPTH;
+}
+/** Whether a step of `tr` can move a block under another container: any replace but
+ *  inline content inside one textblock, which is every keystroke's. Mark and attribute
+ *  steps move no node. */
+function mayNest(tr) {
+    return tr.steps.some((step, i) => {
+        if (step instanceof ReplaceAroundStep)
+            return true;
+        if (!(step instanceof ReplaceStep))
+            return false;
+        const doc = tr.docs[i];
+        const $from = doc.resolve(step.from);
+        if (!$from.parent.isTextblock || !$from.sameParent(doc.resolve(step.to)))
+            return true;
+        let block = false;
+        step.slice.content.forEach((node) => (block ||= node.isBlock));
+        return block;
+    });
+}
+/**
+ * Refuses a transaction leaving `doc` past {@link MAX_NESTING_DEPTH}, which the commit
+ * would lose: a paste or a drop into a deep item, whose slice the import bounded alone.
+ * The nesting commands ask first and keep their key; this is what reaches the rest, and
+ * a refused paste lands nothing. Past the bound, a transaction passes where it leaves the
+ * deepest level no deeper, so a body that arrived that deep keeps its Enter.
+ */
+export function nestingPlugin() {
+    return new Plugin({
+        filterTransaction: (tr) => {
+            if (!tr.docChanged || !mayNest(tr))
+                return true;
+            const after = nestingDepth(tr.doc);
+            return after <= MAX_NESTING_DEPTH || after <= nestingDepth(tr.before);
+        }
+    });
+}

package/dist/core/codec/prose.css

@@ -148,6 +148,20 @@ li.ProseMirror-selectednode::after {
 	font-size: inherit;
 }
 
+/* A fence's language at the label rung in its top corner, read off the `data-lang` the
+   node writes (`schema.ts`). Generated content, so it is never text the caret reaches
+   or a copy takes; the code's lines wrap around it. Read-only: the language is changed
+   in source mode. */
+.ProseMirror pre[data-lang]::before {
+	content: attr(data-lang);
+	float: inline-end;
+	margin-inline-start: var(--_qm-space-3);
+	font-size: var(--_qm-text-label);
+	color: var(--_qm-ink-label);
+	user-select: none;
+	pointer-events: none;
+}
+
 /* A link takes the surface's ink (the UA's blue is the `#8cf` defect again) and a
    dotted underline. Dotted rather than solid because `underline` is a mark in the
    same schema, and a solid rule renders an authored `<u>` and a link identically in a
@@ -191,6 +205,59 @@ li.ProseMirror-selectednode::after {
 	list-style: revert;
 }
 
+/* A task item's checkbox (`tasks.ts`) stands after the item's marker and ahead of its
+   first line, the text wrapping back under it, as the paper sets the box. Its face is a
+   matrix tick's: the input drawn `appearance: none` as an edged well, held at the
+   accent, the check glyph over it in the surface ink. A disabled box is a held leaf's
+   or a copy's, and takes no press. */
+.ProseMirror .qm-task {
+	position: relative;
+	float: left;
+	display: flex;
+	align-items: center;
+	height: 1lh;
+	margin-right: var(--_qm-space-2);
+}
+.ProseMirror .qm-task-box {
+	appearance: none;
+	margin: 0;
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+	border: var(--_qm-border-width) solid var(--_qm-border);
+	border-radius: calc(var(--_qm-radius-inner) / 2);
+	background: var(--_qm-surface-well);
+	cursor: pointer;
+	transition:
+		background-color var(--_qm-duration-fast) var(--_qm-ease-reverse),
+		border-color var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.ProseMirror .qm-task-box:checked {
+	background: var(--_qm-accent);
+	border-color: var(--_qm-accent);
+}
+.ProseMirror .qm-task-box:disabled {
+	cursor: default;
+}
+.ProseMirror .qm-task-box:focus-visible {
+	outline: var(--_qm-ring);
+	outline-offset: var(--_qm-ring-offset);
+}
+.ProseMirror .qm-task-mark {
+	position: absolute;
+	top: 50%;
+	left: 0;
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+	translate: 0 -50%;
+	pointer-events: none;
+	color: var(--_qm-surface);
+	opacity: 0;
+	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.ProseMirror .qm-task:has(:checked) .qm-task-mark {
+	opacity: 1;
+}
+
 /* Six levels, one weight, no size step. The quill reads no level at all, so a size
    ramp here would be the editor predicting a hierarchy the paper does not set; the
    level stays in the model, which is where the codec round-trips it. It is also all
@@ -516,37 +583,24 @@ li.ProseMirror-selectednode::after {
 	height: var(--_qm-tap-min);
 }
 /* The reveal is the control's own (CODEC §"The table island"): one comes up while the
-   pointer is on that control, while it holds the focus, or while it is what a gesture is
-   about — the selected line's grip, and the lifted one, which is drawn through a drag the
+   pointer is on that control, or while it is what a gesture is about — the selected line's grip, and the lifted one, which is drawn through a drag the
    pointer has travelled off. A cell under the pointer draws its row's and its column's
    grips (`table-view.ts` §`onHover`), one pill on each axis and none anywhere else.
 
    Opacity rather than absence, so every control keeps its box and is hit-tested wherever
-   it sits. A grip's reach is the pointer's alone and it holds no focus, so it carries no
-   focus rung: what a keyboard draws a line with is the cell the selection runs through
-   (`table-view.ts` §`cellKeys`), and the wash and the selected grip's tint are what say
-   so. The two bars are in the tab order, the Tab that declines off the last cell landing
-   on them, so the rung there draws one a keyboard has reached. */
+   it sits. A grip's reach and a bar's are the pointer's alone and neither holds focus, so
+   neither carries a focus rung: what a keyboard draws a line with is the cell the
+   selection runs through (`table-view.ts` §`cellKeys`), and the wash and the selected
+   grip's tint are what say so. */
 :is(.qm-table-grip, .qm-table-add) {
 	opacity: 0;
 	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
 }
-.qm-table-add:is(:hover, :focus-visible),
+.qm-table-add:hover,
 .qm-table-grip:is([data-near], :hover, [aria-pressed='true'], .qm-table-lifted) {
 	opacity: 1;
 }
 
-/* The ring, on the two add bars and nowhere else in this file. A prose leaf's focus
-   indicator is its caret and a cell's is too, so the outline is dropped there; a control
-   that comes up out of nothing has the reveal, and a ring under a keyboard is what says
-   the focus is there rather than on the paper behind it. Declared here rather than
-   reached for as `.qm-focus-ring`: that recipe is the visual tier's stylesheet, and the
-   island is inside the leaf, which is the codec's. */
-.qm-table-add:focus-visible {
-	outline: var(--_qm-ring);
-	outline-offset: var(--_qm-ring-offset);
-}
-
 /* A weighted table spans the leaf, laid out fixed, so the stored weights are the
    proportions its columns draw, as the page's fractional columns span the text block
    (`table-view.ts` §`weigh`). An auto-fit table keeps its content's width. */
@@ -610,7 +664,7 @@ li.ProseMirror-selectednode::after {
 	display: none;
 }
 /* The header toggle hangs under the first row's last cell, flush with the grid's
-   trailing edge, clear of whatever a held row raises over its first. */
+   trailing edge. */
 .qm-table-align[data-header] {
 	margin-inline: auto 0;
 }

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

@@ -23,7 +23,7 @@ export declare const plaintextSchema: Schema<string, never>;
  */
 export declare const cellSchema: Schema<"hard_break", string>;
 /**
- * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, no
  * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
  * for the reason {@link plaintextSchema} is.
  *
@@ -38,7 +38,7 @@ export declare function leafSchema(opts: {
     plaintext?: boolean;
     inline?: boolean;
 }): Schema;
-/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+/** Whether `schema` can carry formatting at all: false for the two mark-free schemas.
  *  What a mark command asks before it offers itself. */
 export declare function hasMarks(schema: Schema): boolean;
 /** True for the one-line schemas, which declare no `hard_break`; decode branches on it. */

package/dist/core/codec/schema.js

@@ -3,9 +3,9 @@
 // (list_item/quote → lists/blockquote); marks mirror the content formatting set.
 // Each set is closed upstream, so the schema names its whole vocabulary and carries
 // nothing inert. `blockSchema` is the full field; `inlineSchema` is the constrained
-// single-textblock form for `richtext(inline)` (one paragraph, no block split, no
-// containers, no islands) and `plaintextSchema` is that one without marks, for
-// `plaintext(inline)`; `plainSchema` is a `plaintext` field without `inline`,
+// single-textblock form for a one-line `richtext` (one paragraph, no block split, no
+// containers, no islands) and `plaintextSchema` is that one without marks, for a
+// one-line `text`; `plainSchema` is a `text` field declaring `multiline: true`,
 // paragraphs and hard breaks and nothing else; `cellSchema` is the inline form with
 // hard breaks, for a table cell. Same decode/lower/position machinery,
 // narrower shapes. Anchors are not marks here (decorations).
@@ -18,6 +18,7 @@
 // marks, a `<table>` being the block leaf's clipboard parser's (`table-paste.ts`).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
+import { taskBody, taskChecked, taskDOM } from './tasks.js';
 import { rendersHref, storableUrl } from './urls.js';
 // ── Marks spelled as style ──────────────────────────────────────────────────
 // A word processor writes formatting as a span's inline style rather than as a tag:
@@ -193,11 +194,19 @@ const blockNodes = {
         parseDOM: [{ tag: 'ul' }],
         toDOM: () => ['ul', 0]
     },
+    // `checked` is a task item's, `null` on every other item (`tasks.ts`).
     list_item: {
         content: 'block+',
         defining: true,
-        parseDOM: [{ tag: 'li' }],
-        toDOM: () => ['li', 0]
+        attrs: { checked: { default: null } },
+        parseDOM: [
+            {
+                tag: 'li',
+                getAttrs: (el) => ({ checked: taskChecked(el) }),
+                contentElement: taskBody
+            }
+        ],
+        toDOM: (node) => node.attrs.checked === null ? ['li', 0] : taskDOM(node.attrs.checked)
     },
     island_block: islandBlockSpec
 };
@@ -254,7 +263,7 @@ export const cellSchema = new Schema({
     marks
 });
 /**
- * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
+ * A `text` field declaring `multiline: true`: paragraphs and hard breaks, no marks, no
  * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free
  * for the reason {@link plaintextSchema} is.
  *
@@ -278,7 +287,7 @@ export function leafSchema(opts) {
         return opts.inline ? plaintextSchema : plainSchema;
     return opts.inline ? inlineSchema : blockSchema;
 }
-/** Whether `schema` can carry formatting at all: false for the two plaintext schemas.
+/** Whether `schema` can carry formatting at all: false for the two mark-free schemas.
  *  What a mark command asks before it offers itself. */
 export function hasMarks(schema) {
     return Object.keys(schema.marks).length > 0;

package/dist/core/codec/table-copy.d.ts

@@ -0,0 +1,17 @@
+import { Plugin } from 'prosemirror-state';
+import type { TableProps } from '@quillmark/wasm';
+/** A block of cells, both corners inclusive, in the row space `table.ts` names. */
+export interface CellRange {
+    r0: number;
+    c0: number;
+    r1: number;
+    c1: number;
+}
+/** The cells of `range` as a `<table>`, the header row in a `<thead>` where the range
+ *  holds it and the table has one. The cells carry their marks and breaks, and nothing
+ *  of the table's layout. */
+export declare function tableElement(props: TableProps, range?: CellRange): HTMLTableElement;
+/** The cells of `range` as tab-separated text, a line a row. */
+export declare function tableText(props: TableProps, range?: CellRange): string;
+/** A block leaf's copy: a table in the slice writes as a table in both spellings. */
+export declare function tableCopyPlugin(): Plugin;

package/dist/core/codec/table-copy.js

@@ -0,0 +1,84 @@
+// A table leaves the editor as the two spellings a table arrives in (`table-paste.ts`):
+// an HTML `<table>` and tab-separated text, what Word, Docs, Excel and Sheets each read.
+// Two copies write them: a held rectangle's cells (`table-view.ts`), and a selection
+// holding a whole island, whose markup keeps the island's own element around the table
+// so a paste inside the editor reads the island back whole.
+import { DOMSerializer } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { decode } from './decode.js';
+import { tablePropsOfNode } from './islands.js';
+import { blockSchema, cellSchema } from './schema.js';
+import { cellAt, cellContent, columnCount, rowCount } from './table.js';
+const whole = (props) => ({
+    r0: 0,
+    c0: 0,
+    r1: rowCount(props) - 1,
+    c1: columnCount(props) - 1
+});
+const cellSerializer = DOMSerializer.fromSchema(cellSchema);
+function cellDOM(tag, cell) {
+    const dom = document.createElement(tag);
+    const paragraph = decode(cellContent(cell), cellSchema).firstChild;
+    if (paragraph)
+        dom.append(cellSerializer.serializeFragment(paragraph.content));
+    return dom;
+}
+/** The cells of `range` as a `<table>`, the header row in a `<thead>` where the range
+ *  holds it and the table has one. The cells carry their marks and breaks, and nothing
+ *  of the table's layout. */
+export function tableElement(props, range = whole(props)) {
+    const table = document.createElement('table');
+    let body;
+    for (let r = range.r0; r <= range.r1; r++) {
+        const head = r === 0 && !props.headless;
+        const section = head ? table.createTHead() : (body ??= table.createTBody());
+        const tr = section.insertRow();
+        for (let c = range.c0; c <= range.c1; c++)
+            tr.append(cellDOM(head ? 'th' : 'td', cellAt(props, r, c)));
+    }
+    return table;
+}
+/** A cell holding a tab, a line end or a quote goes in quotes with its quotes doubled,
+ *  as Excel and Sheets write one. */
+function tsvCell(text) {
+    return /[\t\n"]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+/** The cells of `range` as tab-separated text, a line a row. */
+export function tableText(props, range = whole(props)) {
+    const lines = [];
+    for (let r = range.r0; r <= range.r1; r++) {
+        const cells = [];
+        for (let c = range.c0; c <= range.c1; c++)
+            cells.push(tsvCell(cellAt(props, r, c).text));
+        lines.push(cells.join('\t'));
+    }
+    return lines.join('\n');
+}
+const base = DOMSerializer.fromSchema(blockSchema);
+/** The island's own element with the table inside it: a paste in the editor matches the
+ *  element and reads `props`, and every other reader finds the table. */
+const islandSerializer = new DOMSerializer({
+    ...base.nodes,
+    island_block: (node) => {
+        const props = tablePropsOfNode(node);
+        const dom = DOMSerializer.renderSpec(document, blockSchema.nodes.island_block.spec.toDOM(node)).dom;
+        if (props)
+            dom.replaceChildren(tableElement(props));
+        return dom;
+    }
+}, base.marks);
+function leafText(node) {
+    const props = node.type === blockSchema.nodes.island_block ? tablePropsOfNode(node) : undefined;
+    if (props)
+        return tableText(props);
+    return node.type.spec.leafText?.(node) ?? '';
+}
+/** A block leaf's copy: a table in the slice writes as a table in both spellings. */
+export function tableCopyPlugin() {
+    return new Plugin({
+        props: {
+            clipboardSerializer: islandSerializer,
+            clipboardTextSerializer: (slice) => slice.content.textBetween(0, slice.content.size, '\n\n', leafText)
+        }
+    });
+}

package/dist/core/codec/table-view.d.ts

@@ -21,18 +21,12 @@ export interface TableChromeStrings {
     /** The two trailing bars, each of which grows the table along its own axis. */
     tableAddRow: string;
     tableAddColumn: string;
-    /** The held column's alignment cluster, a name per toggle, and the held cells'
-     *  cluster, which takes these three and the vertical three beside them. */
+    /** The held column's alignment cluster, a name per toggle. */
     tableAlignLeft: string;
     tableAlignCenter: string;
     tableAlignRight: string;
     /** The held first row's toggle, pressed while the row draws as the header. */
     tableHeaderToggle: string;
-    tableAlignTop: string;
-    tableAlignMiddle: string;
-    tableAlignBottom: string;
-    /** The held cells' cluster's own name. */
-    tableCellAlignment: string;
 }
 /**
  * The package's English for the island chrome. It lives here, beside the surface