edytor 2.0.0 → 4.0.0

package/dist/surface/observer.svelte.js

@@ -38,7 +38,9 @@ import { diffText } from '../utils/diffText.js';
 import { jsonEquals } from '../utils/json.js';
 import { activeMarks, marksForInsertion } from '../session/editing/text.js';
 import { INTENTS } from '../session/attempt.js';
-import { getCollapsedDomTextSelection, handleNativeLineBreakTextValue, readDomText } from '../events/onInput.js';
+import { runOccurrence } from '../events/onBeforeInput.js';
+import { getDomSelectionSnapshot } from '../selection/domSelection.js';
+import { domOffsetIn } from '../selection/selection.utils.js';
 import { diverges, heal, ownedOf } from './attributes.js';
 import { getTextContentOffsetAtPoint } from '../events/domTextOffset.js';
 import { rendersMark } from './cells.js';
@@ -67,22 +69,68 @@ const textOf = (cell) => cell.runs
     .replace(ZWSP, '');
 /** Svelte's anchors: comments and empty text nodes are never input and never removed. */
 const isAnchor = (node) => node.nodeType === Node.COMMENT_NODE || (node.nodeType === Node.TEXT_NODE && !node.nodeValue);
-/** Non-empty text nodes under `node`. */
-const leaves = (node) => {
+/** The `nth` non-empty text node under `node`. */
+const textLeaf = (node, nth = 0) => {
     const walker = (node.ownerDocument ?? document).createTreeWalker(node, NodeFilter.SHOW_TEXT);
-    let count = 0;
     while (walker.nextNode())
-        if (walker.currentNode.data)
-            count++;
-    return count;
-};
-const firstLeaf = (node) => {
-    const walker = (node.ownerDocument ?? document).createTreeWalker(node, NodeFilter.SHOW_TEXT);
-    while (walker.nextNode())
-        if (walker.currentNode.data)
+        if (walker.currentNode.data && nth-- === 0)
             return walker.currentNode;
     return null;
 };
+const ZERO_WIDTH_SPACE = '\u200B';
+/**
+ * What the browser shows for `text`: its element's text nodes in order (WebKit's
+ * converted-space wrappers read as plain spaces), the empty filler and the
+ * trailing-newline marker stripped.
+ */
+export const readDomText = (text) => {
+    let value = '';
+    const node = text.node;
+    if (node) {
+        const walker = (node.ownerDocument ?? document).createTreeWalker(node, NodeFilter.SHOW_TEXT);
+        while (walker.nextNode()) {
+            const leaf = walker.currentNode;
+            value += leaf.parentElement?.closest('span.Apple-converted-space')
+                ? leaf.data.replaceAll('\u00A0', ' ')
+                : leaf.data;
+        }
+    }
+    // An empty text's filler shares its node with what the browser typed, on either side.
+    if (text.isEmpty)
+        return value.replaceAll(ZERO_WIDTH_SPACE, '');
+    if (text.endsWithNewline && value.endsWith(ZERO_WIDTH_SPACE)) {
+        value = value.slice(0, -ZERO_WIDTH_SPACE.length);
+    }
+    return value;
+};
+export const getCollapsedDomTextSelection = (edytor) => {
+    const selection = getDomSelectionSnapshot(edytor.node);
+    if (!selection?.anchorNode || !selection.isCollapsed) {
+        return null;
+    }
+    if (!edytor.node?.contains(selection.anchorNode)) {
+        return null;
+    }
+    const text = edytor.selection.getTextOfNode(selection.anchorNode);
+    if (!text?.node) {
+        return null;
+    }
+    // No model rule here: the DOM caret is read BEFORE the reconcile writes
+    // the model, so a native insertion legitimately sits past `text.length`
+    // (`selectText` clamps the final write).
+    return { text, offset: domOffsetIn(text, selection.anchorNode, selection.anchorOffset) };
+};
+/** A native line break (a diff inserting only newlines at `at`) runs as the key's occurrence. */
+export const lineBreak = async (edytor, text, value, at) => {
+    if (!text.isInDocument)
+        return;
+    const inputType = edytor.attempts.confirm()?.inputType === 'insertLineBreak' || value.includes('\n')
+        ? 'insertLineBreak'
+        : 'insertParagraph';
+    text.refreshFromModel();
+    edytor.selection.selectText(text, at);
+    await runOccurrence(edytor, { inputType, cancelable: false });
+};
 const settle = (promises) => Promise.all(promises).then(() => undefined);
 /** The collapsed DOM caret's text offset inside `nodes` (a replacement's), if it is there. */
 const caretIn = (nodes) => {
@@ -139,7 +187,7 @@ export class SurfaceObserver {
     #heals = 0;
     /** The pass wrote the host itself: a render (the projector displays after it). */
     #wrote = false;
-    /** Records arrived since the last pass (a display waiting on them gets a pass). */
+    /** Records arrived since the last pass (the projector reads what they did: `rendered`). */
     #fresh = false;
     #window = null;
     constructor(edytor) {
@@ -167,9 +215,16 @@ export class SurfaceObserver {
             clearTimeout(this.#window ?? undefined);
         };
     };
-    /** Register an element the core rendered (an attachment); returns its release. */
+    /**
+     * Register an element the core rendered (an attachment); returns its
+     * release. A text element takes the table's attributes now (its id, its
+     * editing host inside a void).
+     */
     register = (node, kind, block, name, owned) => {
-        this.#registry.set(node, { kind, block, name, owned });
+        const entry = { kind, block, name, owned };
+        this.#registry.set(node, entry);
+        if (kind === 'text')
+            heal(node, ownedOf(this.edytor, node, entry));
         if (kind === 'block')
             this.#blocks.set(block, node);
         else if (kind !== 'anchor' && kind !== 'preview') {
@@ -479,7 +534,7 @@ export class SurfaceObserver {
         }
         if (this.#fresh) {
             this.#fresh = false;
-            void settle(work).then(edytor.projector.inputHandled);
+            void settle(work).then(edytor.projector.rendered);
         }
         return work;
     };
@@ -579,7 +634,7 @@ export class SurfaceObserver {
             const shown = deltas.length ? deltas : [{ text: '\u200B' }];
             for (const [i, delta] of shown.entries()) {
                 const node = nodes[i];
-                const leaf = node?.nodeType === Node.TEXT_NODE ? node : node && firstLeaf(node);
+                const leaf = node?.nodeType === Node.TEXT_NODE ? node : node && textLeaf(node);
                 if (!leaf)
                     return false;
                 if (leaf.data !== delta.text)
@@ -614,7 +669,7 @@ export class SurfaceObserver {
             const at = replaced ? replaced.caret : caret?.text === text ? caret.offset : undefined;
             const line = diffText(text.stringContent, dom);
             if (line && !line.remove && /^[\r\n]+$/.test(line.insert)) {
-                work.push(handleNativeLineBreakTextValue(edytor, text, dom));
+                work.push(lineBreak(edytor, text, dom, line.at));
                 continue;
             }
             work.push(adopt(edytor, text, dom, at));
@@ -698,7 +753,7 @@ export class SurfaceObserver {
                 if (marks.join() !== chain.join())
                     return 'mark-chain';
                 // The snippet's markup is its own, but the delta renders one text node.
-                if (leaves(node) !== 1)
+                if (!textLeaf(node) || textLeaf(node, 1))
                     return 'mark-text';
             }
         }

package/dist/surface/overlay.d.ts

@@ -50,20 +50,6 @@ export declare const pin: (host: HTMLElement) => CSSStyleDeclaration & {
     left: string;
     top: string;
 };
-/**
- * A popup's place near `rect` (client px), 8px inside the viewport: `gap`
- * below it, above it when there is no room below (`above`: above first,
- * below when there is no room above), its left edge at `rect`'s or
- * centered on it (`center`). Measured now from `box` (the host's first
- * element by default; `fallback` before it has a size), written by the
- * answer (the overlay's read-then-write pass).
- */
-export declare const placeNear: (host: HTMLElement, rect: DOMRect, fallback: readonly [width: number, height: number], { gap, above, center, box }?: {
-    gap?: number;
-    above?: boolean;
-    center?: boolean;
-    box?: Element | null;
-}) => (() => void) | void;
 export declare class Overlay {
     #private;
     /** The layer: absolutely positioned at its static place right after the host. */

package/dist/surface/overlay.js

@@ -68,31 +68,6 @@ export const sameValues = (a, b) => a === b ||
         Object.keys(a).every((key) => a[key] === b[key]));
 /** A mounted host whose chrome places itself layer-relative: pinned at the layer's origin. */
 export const pin = (host) => Object.assign(host.style, { position: 'absolute', left: '0px', top: '0px' });
-/**
- * A popup's place near `rect` (client px), 8px inside the viewport: `gap`
- * below it, above it when there is no room below (`above`: above first,
- * below when there is no room above), its left edge at `rect`'s or
- * centered on it (`center`). Measured now from `box` (the host's first
- * element by default; `fallback` before it has a size), written by the
- * answer (the overlay's read-then-write pass).
- */
-export const placeNear = (host, rect, fallback, { gap = 8, above = false, center = false, box = host.firstElementChild } = {}) => {
-    const view = host.ownerDocument.defaultView;
-    if (!view)
-        return;
-    const size = box?.getBoundingClientRect();
-    const width = size?.width || fallback[0];
-    const height = size?.height || fallback[1];
-    const x = center ? rect.left + rect.width / 2 - width / 2 : rect.left;
-    const [below, up] = [rect.bottom + gap, rect.top - gap - height];
-    const y = above
-        ? up >= 8
-            ? up
-            : below
-        : Math.max(8, below + height < view.innerHeight ? below : up);
-    const left = `${Math.max(8, Math.min(x, view.innerWidth - width - 8))}px`;
-    return () => Object.assign(host.style, { left, top: `${y}px` });
-};
 /** The band around the viewport (`near`) whose blocks' resizes are watched, in screens above and below. */
 const NEAR_SCREENS = 1;
 export class Overlay {

package/dist/surface/projector.svelte.d.ts

@@ -28,11 +28,23 @@ export declare class Projector {
      * removal re-rendering the text under a range) runs now. The flag is no
      * reactive source, so no later flush is owed: without this, the range the
      * render moved (Firefox keeps it where the removed element stood) would be
-     * adopted as the gesture's when its `selectionchange` lands. The observer
-     * calls it too once it processed DOM records: a display that waits gets a
-     * pass.
+     * adopted as the gesture's when its `selectionchange` lands.
      */
     inputHandled: () => void;
+    /**
+     * The observer compared the records of a DOM change (a render, a browser
+     * edit): a display that waits on them gets a pass (`inputHandled`), and a
+     * DOM selection they moved off the last observation with no gesture since
+     * is render drift no event reports (`sel.drift.unreported`). A render no
+     * commit asked for (a kind's decoration reading state of its own: a code
+     * grammar that lands re-tokenizes its lines) replaced the text node the
+     * caret was in; the browser left the caret where that node stood (the
+     * line's start) and Chromium and WebKit send no `selectionchange` for it,
+     * while one that comes would read as foreign (no flush ran the projector
+     * since). The value is displayed again now, in the render's own task:
+     * before a key, or its `beforeinput` declaring that caret, can read it.
+     */
+    rendered: () => void;
     /**
      * Classify a `selectionchange` by comparing the DOM selection with the
      * last display, the render epoch and the gesture serial:

package/dist/surface/projector.svelte.js

@@ -34,7 +34,9 @@
  * the render epoch and the gesture serial: echo, render drift (displayed
  * again), composition, foreign write or intent (adopted). Two named, counted,
  * time-bounded browser rules are the only signatures:
- * the Android post-delete snap-back and the IME post-commit jump.
+ * the Android post-delete snap-back and the IME post-commit jump. A render
+ * that moved the DOM selection with no event to say so is drift too, read
+ * from the observer's records (`rendered`, `sel.drift.unreported`).
  */
 import { untrack } from 'svelte';
 import { clearDomSelection, createDomRange, getActiveElement, getDomSelection, getDomSelectionSnapshot, scrollCaretIntoView } from '../selection/domSelection.js';
@@ -88,6 +90,8 @@ export class Projector {
     #opening = false;
     /** The gesture serial at the last observation (a display or an adopted `selectionchange`). */
     #serial = -1;
+    /** Where the DOM selection was at that observation (`#note`; null: no range). */
+    #at = null;
     /** The named rules' evidence: the last model-owned delete and the last IME commit. */
     #deleted = null;
     #committed = null;
@@ -183,14 +187,51 @@ export class Projector {
      * removal re-rendering the text under a range) runs now. The flag is no
      * reactive source, so no later flush is owed: without this, the range the
      * render moved (Firefox keeps it where the removed element stood) would be
-     * adopted as the gesture's when its `selectionchange` lands. The observer
-     * calls it too once it processed DOM records: a display that waits gets a
-     * pass.
+     * adopted as the gesture's when its `selectionchange` lands.
      */
     inputHandled = () => {
         if (this.#pending)
             this.edytor.surface.update();
     };
+    /**
+     * The observer compared the records of a DOM change (a render, a browser
+     * edit): a display that waits on them gets a pass (`inputHandled`), and a
+     * DOM selection they moved off the last observation with no gesture since
+     * is render drift no event reports (`sel.drift.unreported`). A render no
+     * commit asked for (a kind's decoration reading state of its own: a code
+     * grammar that lands re-tokenizes its lines) replaced the text node the
+     * caret was in; the browser left the caret where that node stood (the
+     * line's start) and Chromium and WebKit send no `selectionchange` for it,
+     * while one that comes would read as foreign (no flush ran the projector
+     * since). The value is displayed again now, in the render's own task:
+     * before a key, or its `beforeinput` declaring that caret, can read it.
+     */
+    rendered = () => {
+        if (this.#unreported())
+            this.edytor.selection.display();
+        else
+            this.inputHandled();
+    };
+    /**
+     * `rendered`'s drift: a text value, no display waiting, no gesture, drag
+     * or composition since the last observation, and the DOM selection in the
+     * host no longer where that observation found it.
+     */
+    #unreported = () => {
+        const { edytor } = this;
+        const { selection } = edytor;
+        const at = this.#at;
+        const node = edytor.node;
+        if (!at || !node || selection.value.kind !== 'text' || edytor.intentSerial !== this.#serial)
+            return false;
+        if (selection.request !== this.#request || selection.dragging || edytor.composition.live)
+            return false;
+        const dom = getDomSelection(node);
+        if (!dom || !isOwnPoint(node, dom.anchorNode))
+            return false;
+        return !(samePoint(at.anchor, dom.anchorNode, dom.anchorOffset) &&
+            samePoint(at.focus, dom.focusNode, dom.focusOffset));
+    };
     /**
      * Classify a `selectionchange` by comparing the DOM selection with the
      * last display, the render epoch and the gesture serial:
@@ -283,9 +324,19 @@ export class Projector {
     /** The DOM selection is observed now (adopted, or ignored by the adopter's own rules). */
     #observed = (observation) => {
         this.#seen = this.#flushes;
-        this.#serial = this.edytor.intentSerial;
+        this.#note();
         return observation;
     };
+    /** An observation: its gesture serial, and where the DOM selection is (`#at`). */
+    #note = () => {
+        const { edytor } = this;
+        this.#serial = edytor.intentSerial;
+        const dom = edytor.node && getDomSelection(edytor.node);
+        this.#at =
+            dom?.anchorNode && dom.focusNode
+                ? { anchor: [dom.anchorNode, dom.anchorOffset], focus: [dom.focusNode, dom.focusOffset] }
+                : null;
+    };
     /** The DOM selection is our last display unchanged, or a text-bound range that shows the value. */
     #echoes = (dom) => {
         const displayed = this.#displayed;
@@ -344,7 +395,7 @@ export class Projector {
     observe = () => {
         this.#parking = false;
         this.#seen = this.#flushes;
-        this.#serial = this.edytor.intentSerial;
+        this.#note();
         this.#displayed = null;
     };
     /** Answers whether the pass completed (false: wait for a later flush). */
@@ -388,7 +439,7 @@ export class Projector {
                 if (inside)
                     clearDomSelection(node);
                 this.#displayed = null;
-                this.#serial = edytor.intentSerial;
+                this.#note();
             }
             return true;
         }
@@ -425,7 +476,7 @@ export class Projector {
         selection.scrollOnDisplay = false;
         this.#displayed = { ...points, epoch: selection.epoch };
         this.#seen = this.#flushes;
-        this.#serial = edytor.intentSerial;
+        this.#note();
         selection.observed({
             edge: isCollapsed ? getMarkEdgeSide(startText, start[0], yStart) : undefined
         });
@@ -467,7 +518,7 @@ export class Projector {
     };
     #write = (dom, { anchor, focus }, collapsed) => {
         this.#parking = false;
-        if (!collapsed && typeof dom.setBaseAndExtent === 'function') {
+        if (!collapsed) {
             try {
                 dom.setBaseAndExtent(anchor[0], anchor[1], focus[0], focus[1]);
                 return;

package/dist/text/text.svelte.js

@@ -1,3 +1,4 @@
+import { cleanups } from '../utils.js';
 import {} from '../utils/json.js';
 import { segmentJSON } from '../session/handles.js';
 /**
@@ -101,20 +102,9 @@ export class Text {
     attach = (node) => {
         this.node = node;
         this.edytor.nodeToText.set(node, this);
+        // Registered, it takes the attribute table's attributes (`surface/attributes.ts`).
         const release = this.edytor.surface.register(node, 'text', this.parent.id);
-        node.setAttribute('data-edytor-id', `${this.id}`);
-        node.setAttribute('data-edytor-text', `true`);
-        const pluginDestroy = this.edytor.plugins.flatMap((plugin) => {
-            const action = plugin.onTextAttached?.({ node, text: this });
-            return typeof action === 'function' ? [action] : [];
-        });
-        let insideVoid = false;
-        for (let block = this.parent; block && !insideVoid; block = block.parent)
-            insideVoid = !!block.definition.void;
-        if (insideVoid) {
-            node.setAttribute('contenteditable', 'true');
-            node.style.outline = 'none';
-        }
+        const pluginDestroy = cleanups(this.edytor.plugins, (plugin) => plugin.onTextAttached?.({ node, text: this }));
         // A display that waited for a mounted destination runs in the next pass.
         this.edytor.projector?.mounted(this);
         return {

package/dist/utils/sanitize.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The sanitizers every reader of untrusted values shares: a link's href and
+ * a CSS colour (marks), read the same by render, the clipboard, HTML and
+ * markdown import and export. Pure: no DOM, no Svelte, Worker-safe.
+ */
+/**
+ * CSS-color sanitizer for `color`/`highlight` marks. The value lands in
+ * `style="color: {value}"` — a `;`/`{`/`}` payload escapes the property
+ * and injects arbitrary declarations (`url()` exfil, `position:fixed`
+ * overlays). Metacharacters, escape/obfuscation sequences, and
+ * resource-loading functions are rejected; real `<color>` values
+ * (`#hex`, `rgb()/hsl()/oklch()/color-mix()/var()`, named colors) pass.
+ */
+export declare const sanitizeCssColorValue: (value: unknown) => string | null;
+/**
+ * Scheme allowlist for link hrefs. `javascript:`/`data:`/`vbscript:`
+ * payloads can arrive through native `insertLink`, pasted HTML, or a
+ * malicious collaborator — and Svelte renders `href` verbatim. The href is
+ * read as the browser's URL parser reads it: it strips C0 controls and
+ * spaces at both ends and tab/newline/CR anywhere (`\u0001javascript:` is
+ * `javascript:` to a browser), then resolves it against a base; only an
+ * allowed scheme, or a relative href that stays relative, passes.
+ */
+export declare const sanitizeLinkHref: (href: unknown) => string | null;
+/**
+ * A web page's URL a media block may store or render: the link sanitizer's
+ * reading of it ({@link sanitizeLinkHref}: ASCII control characters and spaces stripped,
+ * tab/newline anywhere), then only an absolute `http:`/`https:` URL with a
+ * host. `null` for anything else: a script or `data:` URL, a `mailto:`, a
+ * relative path, a bare domain.
+ */
+export declare const safeWebUrl: (value: unknown) => string | null;
+/**
+ * A media file's source (a video, an audio track, an attachment): a
+ * {@link safeWebUrl}, or a `blob:` URL an upload answered. Never `data:`:
+ * an inline file would be stored in the document and sent in every update.
+ */
+export declare const safeMediaSrc: (value: unknown) => string | null;

package/dist/utils/sanitize.js

@@ -0,0 +1,82 @@
+/**
+ * The sanitizers every reader of untrusted values shares: a link's href and
+ * a CSS colour (marks), read the same by render, the clipboard, HTML and
+ * markdown import and export. Pure: no DOM, no Svelte, Worker-safe.
+ */
+const SAFE_LINK_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'tel:']);
+/**
+ * CSS-color sanitizer for `color`/`highlight` marks. The value lands in
+ * `style="color: {value}"` — a `;`/`{`/`}` payload escapes the property
+ * and injects arbitrary declarations (`url()` exfil, `position:fixed`
+ * overlays). Metacharacters, escape/obfuscation sequences, and
+ * resource-loading functions are rejected; real `<color>` values
+ * (`#hex`, `rgb()/hsl()/oklch()/color-mix()/var()`, named colors) pass.
+ */
+export const sanitizeCssColorValue = (value) => {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length > 128)
+        return null;
+    if (/[;{}<>\\'"`]/.test(trimmed) || /url\s*\(|expression\s*\(|\/\*|\*\//i.test(trimmed)) {
+        return null;
+    }
+    return trimmed;
+};
+/**
+ * Scheme allowlist for link hrefs. `javascript:`/`data:`/`vbscript:`
+ * payloads can arrive through native `insertLink`, pasted HTML, or a
+ * malicious collaborator — and Svelte renders `href` verbatim. The href is
+ * read as the browser's URL parser reads it: it strips C0 controls and
+ * spaces at both ends and tab/newline/CR anywhere (`\u0001javascript:` is
+ * `javascript:` to a browser), then resolves it against a base; only an
+ * allowed scheme, or a relative href that stays relative, passes.
+ */
+export const sanitizeLinkHref = (href) => {
+    const trimmed = hrefOf(href);
+    // A relative href resolves to the base's `https:`: it names no scheme of its own.
+    return trimmed &&
+        SAFE_LINK_PROTOCOLS.has(urlOf(trimmed, 'https://relative.invalid/')?.protocol ?? '')
+        ? trimmed
+        : null;
+};
+/**
+ * A href as the browser's URL parser reads it: C0 controls and spaces
+ * stripped at both ends, tab/newline/CR anywhere; `''` for a non-string
+ * (marks arrive from untrusted sources too: synced peers, paste).
+ */
+const hrefOf = (href) => typeof href === 'string'
+    ? // eslint-disable-next-line no-control-regex
+        href.replace(/[\t\n\r]/g, '').replace(/^[\u0000-\u0020]+|[\u0000-\u0020]+$/g, '')
+    : '';
+/** `href` parsed (against `base`), or `undefined` when it is no URL. */
+const urlOf = (href, base) => {
+    try {
+        return new URL(href, base);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * A web page's URL a media block may store or render: the link sanitizer's
+ * reading of it ({@link sanitizeLinkHref}: ASCII control characters and spaces stripped,
+ * tab/newline anywhere), then only an absolute `http:`/`https:` URL with a
+ * host. `null` for anything else: a script or `data:` URL, a `mailto:`, a
+ * relative path, a bare domain.
+ */
+export const safeWebUrl = (value) => {
+    const href = hrefOf(value);
+    const url = href ? urlOf(href) : undefined;
+    return url && /^https?:$/.test(url.protocol) && url.host ? href : null;
+};
+/**
+ * A media file's source (a video, an audio track, an attachment): a
+ * {@link safeWebUrl}, or a `blob:` URL an upload answered. Never `data:`:
+ * an inline file would be stored in the document and sent in every update.
+ */
+export const safeMediaSrc = (value) => {
+    const blob = typeof value === 'string' ? /^blob:(.*)$/is.exec(value.trim()) : null;
+    const origin = blob && safeWebUrl(blob[1]);
+    return origin ? `blob:${origin}` : safeWebUrl(value);
+};

package/dist/utils.d.ts

@@ -15,3 +15,5 @@ export declare class PreventionError extends Error {
 export declare const isPrevention: (error: unknown) => error is PreventionError;
 /** A hook's `prevent`: veto the gesture, and optionally run `cb` in its place. */
 export type Prevent = (cb?: () => void) => void;
+/** The cleanups `call` answers for each of `items` (a hook answers a function or nothing). */
+export declare const cleanups: <T>(items: readonly T[], call: (item: T) => unknown) => (() => void)[];

package/dist/utils.js

@@ -39,3 +39,8 @@ export const vetoable = (call) => {
         throw veto;
     return out;
 };
+/** The cleanups `call` answers for each of `items` (a hook answers a function or nothing). */
+export const cleanups = (items, call) => items.flatMap((item) => {
+    const action = call(item);
+    return typeof action === 'function' ? [action] : [];
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "edytor",
 	"license": "MIT",
-	"version": "2.0.0",
+	"version": "4.0.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/beynar/edytor.git"
@@ -50,6 +50,9 @@
 		"bench:browser": "node bench/browser.js",
 		"bench:runs": "BENCH_RUNS=1 vitest --config ./vitest.crdt.config.ts --run src/tests/crdt/runs/runs.bench.test.ts",
 		"size": "node scripts/bundle-size.mjs --by dir",
+		"registry:build": "shadcn-svelte registry build ./registry.json --output site/public/r",
+		"check:registry": "node scripts/check-registry.mjs",
+		"test:registry-install": "sh tests/registry-install/run.sh",
 		"census": "node scripts/census.mjs"
 	},
 	"exports": {
@@ -66,6 +69,10 @@
 			"types": "./dist/crdt/index.d.ts",
 			"default": "./dist/crdt/index.js"
 		},
+		"./export": {
+			"types": "./dist/export/index.d.ts",
+			"default": "./dist/export/index.js"
+		},
 		"./protocol": {
 			"types": "./dist/crdt/protocol.d.ts",
 			"default": "./dist/crdt/protocol.js"
@@ -99,6 +106,9 @@
 		"@cloudflare/vitest-plugin": "1.3.0",
 		"@cloudflare/workers-types": "^5.20260927.1",
 		"@eslint/js": "^10.0.1",
+		"@floating-ui/dom": "1.8.0",
+		"@internationalized/date": "^3.12.4",
+		"@lucide/svelte": "^1.56.0",
 		"@playwright/test": "^1.59.1",
 		"@sveltejs/adapter-static": "^3.0.10",
 		"@sveltejs/kit": "^2.55.0",
@@ -110,6 +120,8 @@
 		"@typescript-eslint/parser": "^8.58.0",
 		"@vitest/ui": "^4.1.2",
 		"@y/protocols": "1.0.6-rc.1",
+		"bits-ui": "^2.19.5",
+		"cn": "^0.4.0",
 		"eslint": "^10.1.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-svelte": "^3.17.0",
@@ -117,12 +129,16 @@
 		"globals": "^17.6.0",
 		"jsdom": "^29.0.1",
 		"katex": "0.18.7",
+		"linkedom": "^0.18.12",
 		"prettier": "^3.8.1",
 		"prettier-plugin-svelte": "^3.5.1",
 		"publint": "^0.3.18",
+		"shadcn-svelte": "^1.7.0",
 		"svelte": "5.55.1",
 		"svelte-check": "^4.4.6",
+		"tailwind-variants": "^3.3.1",
 		"tailwindcss": "^4.2.2",
+		"tw-animate-css": "^1.4.0",
 		"typescript": "^5.9.3",
 		"vite": "^8.0.3",
 		"vitest": "^4.1.2",
@@ -147,7 +163,8 @@
 		}
 	},
 	"dependencies": {
-		"@tanstack/highlight": "^0.1.0",
+		"@tanstack/highlight": "^1.1.0",
+		"@tanstack/markdown": "1.0.0",
 		"esm-env": "^1.2.2",
 		"lib0-v14": "npm:lib0@1.0.0-rc.32"
 	}