@quillmark/svelte 0.27.0 → 0.28.0

package/dist/core/codec/islands.js

@@ -1,35 +1,28 @@
-// 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 every other type inline. The node carries `id`, `islandType` and `props`
-// verbatim.
+// 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 every
+// other type 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. `type` is a closed set, so a
-// discriminant check narrows it; `props` still crosses the DOM as opaque JSON,
-// which is what §`tablePropsOfNode` guards.
+// `ContentIsland.props` is the typed union at the boundary (DOCUMENT_MODEL §Stability seams), so a
+// discriminant check narrows it; `props` still crosses the DOM as opaque JSON, which
+// §`tablePropsOfNode` guards.
 import { Fragment, Slice } from 'prosemirror-model';
 import { Plugin } from 'prosemirror-state';
 import { storableUrl } from './urls.js';
 /** The `U+FFFC` object-replacement char that occupies one island slot in `text`. */
 export const ISLAND_SLOT = '';
-// 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`.
+// The three island node attributes carry the content entry verbatim: `id` is the stable identity
+// (rebases like an anchor), `islandType` the discriminator, `props` the payload preserved
+// byte-for-byte. `islandType` and `props` declare no default: a node standing for an island holds
+// one.
 const islandAttrs = {
     id: { default: '' },
     islandType: {},
     props: {}
 };
-// 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
-// what the rule requires: an island is a leaf, so a rule reading a tag someone else
-// chose would swallow that element's whole subtree.
+// All three attributes cross the DOM, since a copy and a paste inside one body run the document
+// through `toDOM`/`parseDOM` (CODEC §"Markdown at the edges") and an island's tags alone say only
+// `[table]`. `props` crosses as JSON. The names are `data-qm-*`, and the id is required: an island
+// is a leaf, so a rule reading someone else's tag would swallow that element's whole subtree.
 /** The DOM an island node writes and reads back, for either spec. */
 function islandDOM(node) {
     return {
@@ -38,11 +31,12 @@ function islandDOM(node) {
         'data-qm-island-props': JSON.stringify(node.attrs.props ?? null)
     };
 }
-/** The island types the content model names, each with whether its markup is a block,
- *  which decides the node its slot decodes to, and whether a leaf edits it. 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. A footnote and
- *  an equation are read, not edited (CODEC §Decode): a leaf holding one is held. */
+/**
+ * The island types the content model names, each with whether its markup is a block (deciding the
+ * node its slot decodes to) and whether a leaf edits it. A `Record` over the boundary's union, so a
+ * member added upstream is a missing key here. A footnote and an equation are read, not edited
+ * (CODEC §Decode): a leaf holding one is held.
+ */
 const ISLANDS = {
     table: { block: true, edited: true },
     image: { block: false, edited: true },
@@ -57,12 +51,12 @@ export function isBlockIsland(type) {
 export function isEditedIsland(type) {
     return ISLANDS[type].edited;
 }
-/** An island node's attributes off that DOM, or `false` where the id is absent or the
- *  type is one no leaf edits — a name the vocabulary does not hold, or a footnote or an
- *  equation, which no gesture mints — 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. */
+/**
+ * An island node's attributes off that DOM, or `false` where the id is absent or the type is one no
+ * leaf edits (an unknown name, a footnote, an equation), so the element's text arrives as text. A
+ * `props` that is not the JSON written above reads as `null`, one of the wrong shape `undefined` at
+ * its reader (§`tablePropsOfNode`): the entry survives as an island of its type.
+ */
 function islandAttrsFromDOM(el) {
     const id = el.getAttribute('data-qm-island-id');
     // Asserted off an untrusted attribute and checked against the set on the next line.
@@ -79,16 +73,17 @@ function islandAttrsFromDOM(el) {
     }
     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. */
+/**
+ * `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.
+ */
 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): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
+/** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom. */
 export const islandBlockSpec = {
     group: 'block',
     atom: true,
@@ -97,8 +92,7 @@ export const islandBlockSpec = {
     parseDOM: [{ tag: 'div[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
     toDOM: (node) => ['div', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
 };
-/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a
- *  `para` line. */
+/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a `para` line. */
 export const islandInlineSpec = {
     group: 'inline',
     inline: true,
@@ -108,9 +102,10 @@ export const islandInlineSpec = {
     parseDOM: [{ tag: 'span[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
     toDOM: inlineIslandDOM
 };
-/** An inline island's DOM: a footnote its reference mark, whose number `prose.css` draws
- *  in reading order and whose note is its title, an equation its TeX between the dollars
- *  that write it, and an image its tag. */
+/**
+ * An inline island's DOM: a footnote its reference mark (number drawn by `prose.css`, note as
+ * title), an equation its TeX between dollars, an image its tag.
+ */
 function inlineIslandDOM(node) {
     const attrs = node.attrs;
     const dom = islandDOM(node);
@@ -123,11 +118,12 @@ function inlineIslandDOM(node) {
     }
     return ['span', dom, `[${attrs.islandType || 'island'}]`];
 }
-/** 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`). */
+/**
+ * Build a content island entry from a PM island node's attrs. 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, so a
+ * payload the arm does not hold is stored, and `undefined` at its reader draws the placeholder
+ * (§`tablePropsOfNode`).
+ */
 export function islandEntryFromNode(attrs) {
     return {
         id: attrs.id,
@@ -135,9 +131,10 @@ export function islandEntryFromNode(attrs) {
         props: attrs.props
     };
 }
-/** The `TableProps` shape, over a value that reached the node off the DOM rather than
- *  out of a decode: the rectangle every reader indexes (`table.ts`), down to the `text`
- *  a row's emptiness is read off. */
+/**
+ * The `TableProps` shape over a value that reached the node off the DOM: the rectangle every reader
+ * indexes (`table.ts`), down to the `text` a row's emptiness is read off.
+ */
 function isTableProps(props) {
     if (typeof props !== 'object' || props === null)
         return false;
@@ -146,32 +143,30 @@ function isTableProps(props) {
         v.every((c) => typeof c === 'object' && c !== null && typeof c.text === 'string');
     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 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`). */
+/**
+ * A node's `TableProps`, or `undefined` for any other island and for a payload of the wrong shape:
+ * the boundary's guard, so a `props` that crossed the DOM is read once here. Every caller draws the
+ * placeholder for `undefined` (`table-view.ts` §`render`).
+ */
 export function tablePropsOfNode(node) {
     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
- * highest id the field already holds, handing out consecutive ids, so a caller placing
- * several islands at once keeps one minter for the lot. A minted id is this tier's to
- * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and never a
- * re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the highest id the
+ * field holds, so a caller placing several islands keeps one minter. A minted id is part of the
+ * document's canonical bytes (CODEC §Islands): a counter over the projection in hand, never a UUID
+ * or clock reading, and never a re-numbering of existing ids.
  *
- * Reads the PM doc rather than the stored content because that is what the caller (an
- * insert command, a paste) holds and what the commit will project: an id minted against
- * a stale content could collide with one the same transaction places.
+ * Reads the PM doc rather than stored content because that is what the caller holds and the commit
+ * will project; a stale content could collide with an id 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. */
+/**
+ * The ids a document holds and the minter continuing past them, off one sweep for the paste pass.
+ */
 function islandState(doc) {
     const held = new Set();
     let next = 0;
@@ -187,20 +182,19 @@ function islandState(doc) {
     });
     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. */
+/** The next island id for a field: one draw from {@link islandMinter}. */
 export function mintIslandId(doc) {
     return islandMinter(doc)();
 }
-/** Either island node: the test the sweep and the paste pass share, so a third island
- *  shape is one arm rather than two. */
+/** Either island node: the test the sweep and the paste pass share. */
 function isIsland(node) {
     return node.type.name === 'island_block' || node.type.name === 'island_inline';
 }
-/** `fragment` with every island whose id is empty or already `taken` minted afresh, 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. */
+/**
+ * `fragment` with every island whose id is empty or already `taken` minted afresh, or `null` where
+ * none was, so 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.
+ */
 function remintIslands(fragment, taken, mint) {
     const out = [];
     let changed = false;
@@ -224,22 +218,18 @@ function remintIslands(fragment, taken, mint) {
     return changed ? Fragment.fromArray(out) : null;
 }
 /**
- * The paste's island pass: an id the field already holds is re-minted on the way in, and
- * an island arriving with none, a table read off foreign markup (`table-paste.ts`), takes
- * its first.
+ * The paste's island pass: an id the field already holds is re-minted on the way in, and an island
+ * arriving with none (a table read off foreign markup, `table-paste.ts`) takes its first.
  *
- * An id is an identity in the content and unique across the field, so two islands
- * wearing one is a projection the store has no shape for. A copy rather than a cut is
- * where that arrives, and a paste out of a second field is the other; a cut pasted back
- * collides with nothing and keeps the identity it had.
+ * Ids are unique across the field, so two islands wearing one is a projection the store has no
+ * shape for. That arrives by a copy or a paste from a second field; a cut pasted back collides with
+ * nothing and keeps its identity.
  *
- * The test is the document as it stands, which a drag moving a selection over an island
- * reads one too many: the original is still there when the slice is transformed and gone
- * when it lands, so that island arrives under a fresh id. A fresh id costs it nothing a
- * duplicate would cost the whole field.
+ * The test is the document as it stands, so a drag moving a selection over an island sees the
+ * original still there and mints a fresh id for the arrival, which costs nothing next to a
+ * duplicate.
  *
- * A plugin prop rather than a view option: the leaf mounts the codec's plugin stack, and
- * which nodes carry an identity is the codec's to know.
+ * A plugin prop rather than a view option: which nodes carry an identity is the codec's to know.
  */
 export function islandPastePlugin() {
     return new Plugin({

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

@@ -1,34 +1,25 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
 /**
- * The list bindings for a block-schema leaf: `{}` for the one-line and plain
- * schemas, which declare no list nodes.
+ * 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
- * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
- * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
- * indentation (`code.ts`). Where every link declines, the body holds the key
- * (`keymap.ts`).
+ * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain; surfaces owning Tab more locally
+ * prepend a link in `keymap.ts` (`prose/canon/VISUAL_EDITOR.md` §Chrome). `Tab` sinks an unnumbered
+ * line alone into a sub-list, any other line its whole item, and a block right after a list into
+ * the list's last item. `Mod-Shift-7` / `Mod-Shift-8` are the list toggle (`list-toggle.ts`).
+ * `Mod-Enter` ticks the task item around the caret (`toggleTask`).
  *
- * `Mod-Shift-7` / `Mod-Shift-8` are the list toggle (`list-toggle.ts`), numbering or
- * bulleting the selection's lines or taking their markers off.
+ * `Enter` is a chain in precedence order: the empty line above an unnumbered one, an empty top-level
+ * middle item out of the list, the marker back on an empty continuation line, `splitListItem` (`splitTaskItem` for
+ * tasks), then `liftListItem`. The split link splits a non-empty item, and on an empty last item
+ * either splits the wrapping item (a nested one, so Enter lifts one level) or bails so the last
+ * link lifts a top-level one to a paragraph.
  *
- * `Tab` sinks an unnumbered line alone into a sub-list, any other line its whole item,
- * and a block right after a list into the list's last item.
- *
- * `Enter` is a chain in precedence order: the empty line above an unnumbered one, the
- * marker off an empty middle item and back on an empty continuation line, then `splitListItem`
- * (`splitTaskItem`, which leaves a task item's new half an open task), then
- * `liftListItem`. The split link carries two behaviors of its own: it splits a
- * non-empty item, and on an empty last item it either splits the wrapping item (a
- * nested one, so Enter lifts exactly one level) or bails so the last link lifts a
- * top-level one out to a paragraph. `Backspace` takes an item's marker off at its
- * start, a top-level continuation line out to full width, and joins a block onto the
- * list it stands after, and both keys over a selection spanning blocks join the lists
- * the delete leaves touching. `Delete` is the marker off at the seam below with the two lines
- * joined, never the line out: a forward delete edits the line after the caret, not its
- * indent. An empty line is neither key's here:
- * the block link takes it ahead of this chain (`blocks.ts`), the caret's own line
- * being a nearer fact than the boundary under it.
+ * `Backspace` takes an item's marker off at its start, a top-level continuation line out to full
+ * width, and joins a block onto the list it follows; over a selection spanning blocks both keys
+ * join the lists the delete leaves touching. `Delete` is the marker off at the seam below with the
+ * two lines joined, never the line out. An empty line is neither key's here: the block link takes
+ * it first (`blocks.ts`).
  */
 export declare function listKeymap(schema: Schema): Record<string, Command>;