@quillmark/svelte 0.10.0 → 0.11.0

package/dist/core/codec/islands.js

@@ -1,32 +1,31 @@
 // 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.
+// block island (a table). 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 payload the codec preserves byte-for-byte across a round-trip, and `loss` how
+// faithfully markdown can carry it. `islandType` and `props` declare no default: a
+// node standing for an island holds one, so the pair is supplied at every `create`.
+// `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. Its default is the weakest
+// claim; decode always supplies the stored value.
 const islandAttrs = {
     id: { default: '' },
-    islandType: { default: '' },
-    props: { default: null },
+    islandType: {},
+    props: {},
     loss: { default: 'unrepresentable' }
 };
 // All four attributes cross the DOM: a copy and a paste inside one body run the document
@@ -44,13 +43,28 @@ function islandDOM(node) {
         '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 two closed sets an element claims a value from. A `Record` over the boundary's own
+// union rather than a literal check, so a member added upstream is a missing key here
+// rather than a silent refusal at the one door with no decode behind it.
+/** The island types the content model names. */
+const ISLAND_TYPES = { table: true, image: true };
+/** The loss classes it names, weakest last: an unrecognized claim takes that one. */
+const LOSS_CLASSES = {
+    lossless: true,
+    degraded: true,
+    unrepresentable: true
+};
+/** 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 || !ISLAND_TYPES[type])
         return false;
     const raw = el.getAttribute('data-qm-island-props');
     let props = null;
@@ -60,12 +74,22 @@ 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), loss: lossFromDOM(el) };
+}
+/** The `loss` an element claims, or the weakest class for a claim outside the set:
+ *  an under-claim keeps a degraded island from re-crossing as a lossless one. */
+function lossFromDOM(el) {
+    const raw = el.getAttribute('data-qm-island-loss');
+    return raw != null && LOSS_CLASSES[raw] ? raw : 'unrepresentable';
+}
+/** `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. */
 export const islandBlockSpec = {
@@ -86,7 +110,11 @@ 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,
@@ -107,13 +135,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 +156,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 +230,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/prose.css

@@ -228,6 +228,16 @@ li.ProseMirror-selectednode::after {
 .ProseMirror > .qm-table-island + * {
 	margin-top: 0;
 }
+/* Width from above, never from the columns. The scroller below caps at `100%` of this
+   box, and a percentage is no cap while an ancestor is being sized to what it holds: a
+   leaf taking its width from its own contents is asked for the table's max-content width
+   and the cap never applies. The surface closes the same question at its edge
+   (`visual/VisualEditorInner.svelte` §`.qm-editor`); this end of it is what makes the cap
+   below true wherever the island lands. `inline-size`, not `size`: an island is as tall
+   as its rows. */
+.qm-table-island {
+	contain: inline-size;
+}
 .qm-table-scroller {
 	/* The one horizontally scrolling box in a leaf: a table is as wide as its
 	   columns, and a wide one must not push the card's own layout. `overflow-y` is

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;