@quillmark/svelte 0.10.1 → 0.12.0

package/dist/core/codec/islands.js

@@ -1,35 +1,29 @@
-// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. A slot
-// inside a `para` line is an inline island (an image); an `island`-kind line is a
-// block island (a table). The node carries `id`, `islandType`, and the opaque
-// `props` verbatim, so an unknown island type round-trips untouched.
+// Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. Every slot sits
+// in a `para` line; the island's type says which node it is, a `table` a block alone on
+// its line and an `image` inline. The node carries `id`, `islandType` and `props` verbatim.
 //
 // A props-aware consumer reads the shape straight off the boundary:
 // `ContentIsland.props` is the typed union (`TableProps` for `table`,
 // `ImageProps` for `image`; DOCUMENT_MODEL §Stability seams), so the codec
-// reads it rather than hand-rolling a shape or guard. The open `type` arm means
-// a discriminant check does not auto-narrow `props`; key off `type` and read
-// `props` as the matching upstream type.
+// reads it rather than hand-rolling a shape. `type` is a closed set, so a
+// discriminant check narrows it; `props` still crosses the DOM as opaque JSON,
+// which is what §`tablePropsOfNode` guards.
 import { Fragment, Slice } from 'prosemirror-model';
 import { Plugin } from 'prosemirror-state';
-import { isTableIsland } from '@quillmark/wasm';
+import { storableUrl } from './urls.js';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export const ISLAND_SLOT = '';
-// The four island node attributes carry the content entry verbatim: `id` is the
-// stable identity (rebases like an anchor), `islandType` the discriminator, `props`
-// the opaque payload the codec preserves byte-for-byte across a round-trip, and
-// `loss` how faithfully markdown can carry it. `loss` is authored, not derived:
-// `applyChange` stores the class an island op gives it and re-derives nothing, so
-// an entry that did not carry its own would promote a degraded table to lossless
-// on the first cell edit. The default is the class an unknown one reads as, so a
-// node no decode produced under-claims rather than over-claims; decode always
-// supplies the stored value.
+// The three island node attributes carry the content entry verbatim: `id` is the
+// stable identity (rebases like an anchor), `islandType` the discriminator, and `props`
+// the payload the codec preserves byte-for-byte across a round-trip. `islandType` and
+// `props` declare no default: a node standing for an island holds one, so the pair is
+// supplied at every `create`.
 const islandAttrs = {
     id: { default: '' },
-    islandType: { default: '' },
-    props: { default: null },
-    loss: { default: 'unrepresentable' }
+    islandType: {},
+    props: {}
 };
-// All four attributes cross the DOM: a copy and a paste inside one body run the document
+// All three attributes cross the DOM: a copy and a paste inside one body run the document
 // through `toDOM`/`parseDOM` (CODEC §"Markdown at the edges"), and an island is a leaf
 // whose tags alone say only `[table]`. `props` crosses as JSON, the form the payload has
 // at the boundary. The names are `data-qm-*` like every other carrier's, and the id is
@@ -40,17 +34,29 @@ function islandDOM(node) {
     return {
         'data-qm-island': node.attrs.islandType,
         'data-qm-island-id': node.attrs.id,
-        'data-qm-island-loss': node.attrs.loss,
         'data-qm-island-props': JSON.stringify(node.attrs.props ?? null)
     };
 }
-/** An island node's attributes off that DOM, or `false` where the id is absent. A
- *  `props` that is not the JSON written above reads as `null`, and one of the wrong
- *  shape is `undefined` at its reader (§`tablePropsOfNode`): the entry survives as an
- *  island of its type rather than taking the paste down with it. */
+/** The island types the content model names, each with whether its markup is a block,
+ *  which decides the node its slot decodes to. A `Record` over the boundary's own union,
+ *  so a member added upstream is a missing key here rather than a silent refusal at the
+ *  one door with no decode behind it. */
+const BLOCK_ISLAND = { table: true, image: false };
+/** Whether an island of `type` is block markup: a `table` stands alone on its line. */
+export function isBlockIsland(type) {
+    return BLOCK_ISLAND[type];
+}
+/** An island node's attributes off that DOM, or `false` where the id is absent or the
+ *  type is one the content vocabulary does not name — a name no read produces and no
+ *  write takes, so the element's text arrives as text. A `props` that is not the JSON
+ *  written above reads as `null`, and one of the wrong shape is `undefined` at its
+ *  reader (§`tablePropsOfNode`): the entry survives as an island of its type rather
+ *  than taking the paste down with it. */
 function islandAttrsFromDOM(el) {
     const id = el.getAttribute('data-qm-island-id');
-    if (id == null)
+    // Asserted off an untrusted attribute and checked against the set on the next line.
+    const type = el.getAttribute('data-qm-island');
+    if (id == null || type == null || !Object.hasOwn(BLOCK_ISLAND, type))
         return false;
     const raw = el.getAttribute('data-qm-island-props');
     let props = null;
@@ -60,14 +66,18 @@ function islandAttrsFromDOM(el) {
     catch {
         props = null;
     }
-    return {
-        id,
-        islandType: el.getAttribute('data-qm-island') ?? '',
-        props,
-        loss: (el.getAttribute('data-qm-island-loss') ?? 'unrepresentable')
-    };
+    return { id, islandType: type, props: storableProps(type, props) };
+}
+/** `props` with the one key the authored lane refuses made storable: an `image`'s `url`
+ *  carrying a line ending, which `IslandOp` and `overwrite` throw on. The rest crosses
+ *  opaque, as it did on the way out. */
+function storableProps(type, props) {
+    if (type !== 'image' || typeof props !== 'object' || props === null)
+        return props;
+    const url = props.url;
+    return typeof url === 'string' ? { ...props, url: storableUrl(url) } : props;
 }
-/** Block island node (a table): one `island`-kind content line. Atom, unselectable content. */
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
 export const islandBlockSpec = {
     group: 'block',
     atom: true,
@@ -86,13 +96,16 @@ export const islandInlineSpec = {
     parseDOM: [{ tag: 'span[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
     toDOM: (node) => ['span', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
 };
-/** Build a content island entry from a PM island node's attrs (block or inline). */
+/** Build a content island entry from a PM island node's attrs (block or inline). The
+ *  cast pairs a closed `type` with a `props` that crossed the DOM as opaque JSON. The
+ *  store is lenient about a table's shape — it fills what it can and keeps the rest —
+ *  so a payload the arm does not hold is stored rather than refused, and `undefined` at
+ *  its reader is what the surface draws the placeholder for (§`tablePropsOfNode`). */
 export function islandEntryFromNode(attrs) {
     return {
         id: attrs.id,
         type: attrs.islandType,
-        props: attrs.props,
-        loss: attrs.loss
+        props: attrs.props
     };
 }
 /** The `TableProps` shape, over a value that reached the node off the DOM rather than
@@ -107,13 +120,13 @@ function isTableProps(props) {
     return (cells(header) && Array.isArray(aligns) && Array.isArray(rows) && rows.every((row) => cells(row)));
 }
 /** A node's `TableProps`, or `undefined` for any other island and for a payload of the
- *  wrong shape: the boundary's own guard over the entry the node carries, so the open
- *  `type` arm narrows once here rather than at each reader. The type says which reader,
- *  the shape says whether it can read; every caller draws the placeholder for
- *  `undefined` (`table-view.ts` §`render`). */
+ *  wrong shape: the boundary's own guard over the entry the node carries, so a `props`
+ *  that crossed the DOM is read once here rather than at each reader. The type says
+ *  which reader, the shape says whether it can read; every caller draws the placeholder
+ *  for `undefined` (`table-view.ts` §`render`). */
 export function tablePropsOfNode(node) {
-    const entry = islandEntryFromNode(node.attrs);
-    return isTableIsland(entry) && isTableProps(entry.props) ? entry.props : undefined;
+    const attrs = node.attrs;
+    return attrs.islandType === 'table' && isTableProps(attrs.props) ? attrs.props : undefined;
 }
 /**
  * A minter over one document: the positional `isl-{n}` sequence continued past the
@@ -128,38 +141,35 @@ export function tablePropsOfNode(node) {
  * a stale content could collide with one the same transaction places.
  */
 export function islandMinter(doc) {
+    return islandState(doc).mint;
+}
+/** The ids a document holds and the minter continuing past them, off one sweep: both
+ *  are the same walk under the same predicate, and the paste pass wants both. */
+function islandState(doc) {
+    const held = new Set();
     let next = 0;
     doc.descendants((node) => {
         if (!isIsland(node))
             return true;
-        const m = /^isl-(\d+)$/.exec(node.attrs.id);
+        const id = node.attrs.id;
+        held.add(id);
+        const m = /^isl-(\d+)$/.exec(id);
         if (m)
             next = Math.max(next, Number(m[1]) + 1);
         return false;
     });
-    return () => `isl-${next++}`;
+    return { held, mint: () => `isl-${next++}` };
 }
 /** The next island id for a field: one draw from {@link islandMinter}, which is what a
  *  command placing exactly one island wants. */
 export function mintIslandId(doc) {
     return islandMinter(doc)();
 }
-/** Either island node: the test the minter, the id sweep and the paste pass share, so a
- *  third island shape is one arm rather than three. */
+/** Either island node: the test the sweep and the paste pass share, so a third island
+ *  shape is one arm rather than two. */
 function isIsland(node) {
     return node.type.name === 'island_block' || node.type.name === 'island_inline';
 }
-/** The ids a document already holds. */
-function heldIds(doc) {
-    const held = new Set();
-    doc.descendants((node) => {
-        if (!isIsland(node))
-            return true;
-        held.add(node.attrs.id);
-        return false;
-    });
-    return held;
-}
 /** `fragment` with every island whose id is already `taken` re-minted, or `null` where
  *  none was: an untouched paste stays the slice it arrived as. Every surviving id joins
  *  the set, so a slice carrying one id twice comes apart in the same pass. */
@@ -205,7 +215,8 @@ export function islandPastePlugin() {
     return new Plugin({
         props: {
             transformPasted: (slice, view) => {
-                const content = remintIslands(slice.content, heldIds(view.state.doc), islandMinter(view.state.doc));
+                const { held, mint } = islandState(view.state.doc);
+                const content = remintIslands(slice.content, held, mint);
                 return content ? new Slice(content, slice.openStart, slice.openEnd) : slice;
             }
         }

package/dist/core/codec/keymap.js

@@ -1,6 +1,7 @@
 import { chainCommands } from 'prosemirror-commands';
 import { atomKeymap } from './atoms.js';
 import { blockKeymap } from './blocks.js';
+import { breakKeymap } from './breaks.js';
 import { codeKeymap } from './code.js';
 import { listKeymap } from './lists.js';
 import { slashKeymap } from './slash.js';
@@ -27,5 +28,5 @@ function chainKeymaps(...maps) {
  * no visible reason. */
 export function bodyKeymap(schema, slash) {
     const links = slash ? [slashKeymap()] : [];
-    return chainKeymaps(...links, blockKeymap(schema), codeKeymap(schema), listKeymap(schema), atomKeymap(schema));
+    return chainKeymaps(...links, blockKeymap(schema), codeKeymap(schema), breakKeymap(schema), listKeymap(schema), atomKeymap(schema));
 }

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

@@ -1,27 +1,31 @@
 import type { Mark, Schema } from 'prosemirror-model';
-import type { ContentMark } from '@quillmark/wasm';
-/** A PM mark from a content formatting/unknown mark, or `null` for an anchor. */
+import type { ContentMark, ContentMarkKind } from '@quillmark/wasm';
+/** A PM mark from a content formatting mark, or `null` for an anchor. Exhaustive over
+ *  the closed mark vocabulary, so a member added upstream is a compile error here rather
+ *  than an index into a PM mark this schema does not declare. */
 export declare function pmMarkFromContent(schema: Schema, m: ContentMark): Mark | null;
 /**
  * A content mark descriptor from a PM mark (range-free): the `{ type, … }` half
- * of a `ContentMark` / `MarkOp`. `strong`/`emph`/… collapse to their content
- * name; the `unknown` mark re-emits its stored `type`/`attrs` verbatim.
+ * of a `ContentMark` / `MarkOp`. `em` collapses to `emph` and a link's `href` rides
+ * out as the `url` its payload spells; the other four are their own content name,
+ * which is what the cast claims.
  */
-export declare function contentDescriptorFromPM(mark: Mark): Record<string, unknown>;
+export declare function contentDescriptorFromPM(mark: Mark): ContentMarkKind;
 /**
  * The range-free `{ type, … }` half of a content mark: `contentDescriptorFromPM`'s
- * content-side twin, and what a `MarkOp` carries beside its range. An anchor keys
- * on its type alone: its `id` is identity, not a formatting family, and the diff
- * routes anchors by id on a separate channel.
+ * content-side twin, and what a `MarkOp` carries beside its range. Lifted off the
+ * range envelope rather than rebuilt arm by arm, so a payload crosses whole and an
+ * arm added upstream reaches this by construction.
  */
-export declare function descriptorOf(m: ContentMark): Record<string, unknown>;
+export declare function descriptorOf(m: ContentMark): ContentMarkKind;
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
- * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
- * (verified), so different urls / attrs are independent mark families.
+ * coverage set. Payload-free formatting keys on its type, everything else on
+ * type+attrs, because `applyChange`'s `remove` matches type and attrs (verified),
+ * so two links differing in url are independent mark families. This is the seam's
+ * own `(type, attrs)` tie-break, which is why no arm needs a case of its own.
  */
-export declare function markKey(descriptor: Record<string, unknown>): string;
+export declare function markKey(descriptor: ContentMarkKind): string;
 /** A held anchor position: an identity id at a USV content offset (zero-width). */
 export interface AnchorPos {
     id: string;

package/dist/core/codec/marks.js

@@ -1,64 +1,61 @@
-import { isAnchorMark, isLinkMark } from '@quillmark/wasm';
-/** Content formatting types that map 1:1 to a same-named PM mark. */
-const PLAIN_FORMATTING = new Set(['strong', 'underline', 'strike', 'code']);
-/** A PM mark from a content formatting/unknown mark, or `null` for an anchor. */
+import { canonicalJson } from './reconcile.js';
+/** A PM mark from a content formatting mark, or `null` for an anchor. Exhaustive over
+ *  the closed mark vocabulary, so a member added upstream is a compile error here rather
+ *  than an index into a PM mark this schema does not declare. */
 export function pmMarkFromContent(schema, m) {
-    if (isAnchorMark(m))
-        return null;
-    if (m.type === 'emph')
-        return schema.marks.em.create();
-    if (isLinkMark(m))
-        return schema.marks.link.create({ href: m.url });
-    if (PLAIN_FORMATTING.has(m.type))
-        return schema.marks[m.type].create();
-    // Anything else is an unknown mark: inert, renders nothing, round-trips verbatim.
-    return schema.marks.unknown.create({
-        type: m.type,
-        attrs: m.attrs ?? null
-    });
+    switch (m.type) {
+        case 'anchor':
+            return null;
+        case 'emph':
+            return schema.marks.em.create();
+        case 'link':
+            return schema.marks.link.create({ href: m.attrs.url });
+        case 'strong':
+        case 'underline':
+        case 'strike':
+        case 'code':
+            return schema.marks[m.type].create();
+        default: {
+            const unreached = m;
+            return unreached;
+        }
+    }
 }
 /**
  * A content mark descriptor from a PM mark (range-free): the `{ type, … }` half
- * of a `ContentMark` / `MarkOp`. `strong`/`emph`/… collapse to their content
- * name; the `unknown` mark re-emits its stored `type`/`attrs` verbatim.
+ * of a `ContentMark` / `MarkOp`. `em` collapses to `emph` and a link's `href` rides
+ * out as the `url` its payload spells; the other four are their own content name,
+ * which is what the cast claims.
  */
 export function contentDescriptorFromPM(mark) {
     const name = mark.type.name;
     if (name === 'em')
         return { type: 'emph' };
     if (name === 'link')
-        return { type: 'link', url: mark.attrs.href };
-    if (name === 'unknown')
-        return { type: mark.attrs.type, attrs: mark.attrs.attrs };
-    // strong / underline / strike / code
+        return { type: 'link', attrs: { url: mark.attrs.href } };
     return { type: name };
 }
 /**
  * The range-free `{ type, … }` half of a content mark: `contentDescriptorFromPM`'s
- * content-side twin, and what a `MarkOp` carries beside its range. An anchor keys
- * on its type alone: its `id` is identity, not a formatting family, and the diff
- * routes anchors by id on a separate channel.
+ * content-side twin, and what a `MarkOp` carries beside its range. Lifted off the
+ * range envelope rather than rebuilt arm by arm, so a payload crosses whole and an
+ * arm added upstream reaches this by construction.
  */
 export function descriptorOf(m) {
-    if (isLinkMark(m))
-        return { type: 'link', url: m.url };
-    if ('attrs' in m && !isAnchorMark(m))
-        return { type: m.type, attrs: m.attrs };
-    return { type: m.type };
+    const { start: _start, end: _end, ...kind } = m;
+    return kind;
 }
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
- * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
- * (verified), so different urls / attrs are independent mark families.
+ * coverage set. Payload-free formatting keys on its type, everything else on
+ * type+attrs, because `applyChange`'s `remove` matches type and attrs (verified),
+ * so two links differing in url are independent mark families. This is the seam's
+ * own `(type, attrs)` tie-break, which is why no arm needs a case of its own.
  */
 export function markKey(descriptor) {
-    const type = descriptor.type;
-    if (type === 'link')
-        return `link\u0000${String(descriptor.url)}`;
-    if (descriptor.attrs !== undefined)
-        return `${type}\u0000${JSON.stringify(descriptor.attrs)}`;
-    return type;
+    if ('attrs' in descriptor)
+        return `${descriptor.type}\u0000${canonicalJson(descriptor.attrs)}`;
+    return descriptor.type;
 }
 /**
  * The identity anchors of a `Content` as `{ id, pos }` in USV: the seed for the
@@ -68,7 +65,7 @@ export function markKey(descriptor) {
 export function anchorsFromContent(rt) {
     const out = [];
     for (const m of rt.marks)
-        if (isAnchorMark(m))
-            out.push({ id: m.id, pos: m.start });
+        if (m.type === 'anchor')
+            out.push({ id: m.attrs.id, pos: m.start });
     return out;
 }

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

@@ -1,5 +1,5 @@
 import type { Node as PMNode } from 'prosemirror-model';
-import { type PosRun } from './encode.js';
+import { type PosRun, type Scan } from './encode.js';
 /** A prebuilt line→position index for a PM doc, rebuilt on structural change. */
 export interface LineIndex {
     runs: PosRun[];
@@ -11,6 +11,9 @@ export interface LineIndex {
 }
 /** Build the position index for `doc` (walks it once via the shared scanner). */
 export declare function buildLineIndex(doc: PMNode): LineIndex;
+/** The index a scan's runs make. The commit path takes this one: it wants the
+ *  content projection off the same walk (`encode.ts`, `scanContent`). */
+export declare function lineIndexOf(s: Scan): LineIndex;
 /** USV content offset → PM position. */
 export declare function usvToPM(index: LineIndex, usvPos: number): number;
 /** PM position → USV content offset. */

package/dist/core/codec/positions.js

@@ -1,7 +1,11 @@
 import { scanDoc } from './encode.js';
 /** Build the position index for `doc` (walks it once via the shared scanner). */
 export function buildLineIndex(doc) {
-    const s = scanDoc(doc);
+    return lineIndexOf(scanDoc(doc));
+}
+/** The index a scan's runs make. The commit path takes this one: it wants the
+ *  content projection off the same walk (`encode.ts`, `scanContent`). */
+export function lineIndexOf(s) {
     const runs = s.runs;
     let pmEndContent = 1;
     let firstContentStart = 1;

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

@@ -24,3 +24,9 @@ export declare function contentEqual(a: Content, b: Content): boolean;
  * on one side and a PM node attribute on the other.
  */
 export declare function valueEqual(a: unknown, b: unknown): boolean;
+/**
+ * A value's canonical string: key-sorted at every depth, so two spellings of one value
+ * mint one key whatever order each side's producer wrote them in. What the key-minting
+ * half of the seam stringifies with, for the reason the equalities deep-compare.
+ */
+export declare function canonicalJson(value: unknown): string;

package/dist/core/codec/reconcile.js

@@ -62,3 +62,22 @@ function deepEqual(a, b) {
     }
     return false;
 }
+/**
+ * A value's canonical string: key-sorted at every depth, so two spellings of one value
+ * mint one key whatever order each side's producer wrote them in. What the key-minting
+ * half of the seam stringifies with, for the reason the equalities deep-compare.
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(canonical(value));
+}
+function canonical(v) {
+    if (Array.isArray(v))
+        return v.map(canonical);
+    if (typeof v !== 'object' || v === null)
+        return v;
+    const o = v;
+    const out = {};
+    for (const k of Object.keys(o).sort())
+        out[k] = canonical(o[k]);
+    return out;
+}

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

@@ -1,12 +1,5 @@
 import { Schema } from 'prosemirror-model';
-/**
- * Whether a link carrying `href` renders as one. A value with no scheme is relative
- * to the embedding page and has none to refuse.
- *
- * A refused href is unchanged: it stays on the mark and round-trips, so a document
- * survives an editor that declines to make it clickable.
- */
-export declare function rendersHref(href: string): boolean;
+import type { NodeType } from 'prosemirror-model';
 /** The full field schema: every block kind, container, mark, and island. */
 export declare const blockSchema: Schema<string, string>;
 /** The constrained inline schema: one paragraph, no block splitting, no
@@ -28,3 +21,7 @@ export declare const plaintextSchema: Schema<string, never>;
 export declare function hasMarks(schema: Schema): boolean;
 /** True for the constrained inline schema (no block containers); decode branches on it. */
 export declare function isInlineSchema(schema: Schema): boolean;
+/** Whether `type` can hold a within-block line break, which a heading cannot (§`heading`).
+ *  What a `\n` landing in a textblock is rewritten to turns on it (`breaks.ts`), and so
+ *  does what decode puts between a block's continued segments. */
+export declare function takesLineBreak(type: NodeType): boolean;