@quillmark/svelte 0.10.1 → 0.12.0

package/dist/core/rungs.js

@@ -0,0 +1,24 @@
+// Where a script reads the scale. The derivation declares every `--_qm-*` rung on
+// `[data-qm-root]` and nowhere else (`core/theme.css`), so a descendant's value is that
+// one inherited and the root is the element the question is about: asking a leaf three
+// containers deep is asking an arbitrary element what the surface is set to.
+//
+// The read is also the cost. `getComputedStyle` compounds with nesting depth under jsdom,
+// so a suite that resolves rungs off landed elements pays the depth of whatever it landed
+// on; resolving them off the root pays the root's.
+/** The element the scale is declared on, for `node`: its root, or `node` where it stands
+ *  outside one (a detached surface, a consumer's own mount). */
+export function rungStyle(node) {
+    return getComputedStyle(node.closest('[data-qm-root]') ?? node);
+}
+/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
+ *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
+ *  empty). No rung, no motion: a fallback here would be the scale restated in the one
+ *  place `check:style` cannot read. */
+export function rungMs(style, rung) {
+    const raw = style.getPropertyValue(rung).trim();
+    const n = Number.parseFloat(raw);
+    if (!Number.isFinite(n))
+        return undefined;
+    return raw.endsWith('ms') ? n : n * 1000;
+}

package/dist/core/theme.css

@@ -336,6 +336,16 @@
 	   through the icon's `size`, so a stylesheet beats the SVG presentation attribute
 	   and one rung is the whole of what a control draws. */
 	--_qm-glyph-control: 14px;
+	/* The narrowest track a control that fills its width stays usable in: a table's
+	   column floors at it, rises no further than its content, and a row of them scrolls
+	   sideways rather than crushing a cell. A column drawing a mark takes no floor — a
+	   switch is one width at every width, so there is no width for it to be usable in
+	   (`ArrayField`). What the field has spare stands after the last column, an inner
+	   grid carrying its own rhythm rather than the card's. Under the field minimum the
+	   capacity ladder steps at (`.qm-tracks`), since a cell in a row has the header to
+	   name it and no label of its own to fit. A threshold rather than a rhythm choice,
+	   so it does not move with `--qm-space`. */
+	--_qm-track-min: 7rem;
 
 	/* ── Type ────────────────────────────────────────────────────────────────
 	   `--qm-font-size` anchors the chrome rung; 1.125 is the ratio between adjacent

package/dist/preset/recipes.css

@@ -112,7 +112,7 @@ html:has(.qm-workspace) {
 	display: none;
 }
 
-/* One mount at A time under the threshold, rather than two of them abreast. Half a narrow
+/* One mount at a time under the threshold, rather than two of them abreast. Half a narrow
    viewport is under the width either surface reads at, so the split stops being one and
    the tracks become views of the same room: the host says which with `data-qm-show`, and
    the attribute names the track rather than what is in it, so nothing here knows an editor

package/dist/preset/scale.css

@@ -1,10 +1,13 @@
-/* The host'S derivation: the same public dials in, a closed `--qmh-*` scale for the
+/* The host's derivation: the same public dials in, a closed `--qmh-*` scale for the
    page around the surfaces out. `core/theme.css` is the same shape one level down
    (dials in, `--_qm-*` out), and the two are calibrated against each other: the
-   figures here are the figures there (the ground step's ramp, 8% hover, 17%
-   border, 45% ink, the ring's width, the status hue at both poles) and the
+   figures here are the figures there (the ground step's ramp, 8% hover, the
+   ring's width, the status hue at both poles) and the
    dial means the same plane in both, so a host plate and a card on it land on the same
-   tone at both poles and a host page meets an editor's own column exactly. The well
+   tone at both poles and a host page meets an editor's own column exactly. The border
+   and ink rungs are each calibrated for their own plane rather than shared: a page's
+   chrome is read at one size against one ground, a card's interior at several against
+   the rungs under it, so the mixes are not the same figure. The well
    under the ground has no counterpart here: a host's own controls are boxed and carry a
    hairline, so nothing on a page needs the step an edgeless field does.
 

package/dist/preview/bridge.d.ts

@@ -35,4 +35,11 @@ export interface VerticalSpan {
  * the port: no scroll shows more of it.
  */
 export declare function clearOfTheFold(target: VerticalSpan, port: VerticalSpan): boolean;
-export declare function createBridge(session: LiveSession, container: HTMLElement, slots: readonly PageSlot[], onPick: ((at: Landing) => void) | undefined): BridgeController;
+/** The trip a pane with no box could not run, held for the box coming back. One, and the
+ *  last one asked for: a caret hop supersedes the hop before it on a showing pane too.
+ *  A cell rather than closure state, so a bridge rebuilt under a changed page count
+ *  inherits what the one it replaced was holding (`controller.ts`). */
+export interface HeldTrip {
+    run?: () => void;
+}
+export declare function createBridge(session: LiveSession, container: HTMLElement, slots: readonly PageSlot[], onPick: ((at: Landing) => void) | undefined, held?: HeldTrip): BridgeController;

package/dist/preview/bridge.js

@@ -1,4 +1,4 @@
-import { boxesForField, rectToPercent, clickToPdfPt, applyPercentRect } from './geometry.js';
+import { boxesForField, rectToPercent, clickToPdfPt, pxToPt, applyPercentRect } from './geometry.js';
 /** A pane hidden by the shell's narrow switch (`preset/recipes.css`) measures 0×0, and so
  *  does every box on it: the clearance arithmetic reads that as a caret clear of both
  *  edges, and a centring computes its trip out of zeros. Neither is an answer about where
@@ -9,6 +9,11 @@ function hasBox(port) {
 /** What a rect reporting no height clears an edge by, in CSS px: a caret's own at the
  *  smallest zoom a page still reads at. */
 const MIN_CLEARANCE = 8;
+/** What a click may miss a field's ink by and still land on it, in CSS px of the page as
+ *  drawn, so it converts per click at the scale the slot is showing. Sized as the
+ *  pointer's imprecision and not as the leading it partly closes, which is a trade
+ *  PREVIEW.md §"Click bridge" carries. */
+const CLICK_SLACK_PX = 2;
 /**
  * Whether `target` sits clear of `port`'s edges by the fold's clearance, which is the
  * target's own height: a caret rect flush against an edge is visible and unusable, and
@@ -29,14 +34,15 @@ export function clearOfTheFold(target, port) {
     const clearance = Math.min(Math.max(target.height, MIN_CLEARANCE), (port.height - target.height) / 3);
     return target.top - clearance >= port.top && target.bottom + clearance <= port.bottom;
 }
-export function createBridge(session, container, slots, onPick) {
+export function createBridge(session, container, slots, onPick, held = {}) {
     const unlisten = [];
     // Two rungs: `positionAt` over span-tracked content, `fieldAt` over every placement
     // the compile tracks, a strict superset of it (PREVIEW.md §"Click bridge" carries
     // the measurement). The second fires where a field is placed without its content
     // being tracked, and the pick carries no `pos` there: a fabricated `0` would be an
     // invented offset wearing a real one's type. No third rung hit-tests `regions()`,
-    // whose rects bound ink the field does not fill.
+    // whose rects bound ink the field does not fill; the slack both rungs carry is what
+    // that rung would have been reached for.
     if (onPick) {
         for (const { page, el } of slots) {
             const handleClick = (ev) => {
@@ -50,10 +56,11 @@ export function createBridge(session, container, slots, onPick) {
                 const px = ev.clientX - box.left;
                 const py = ev.clientY - box.top;
                 const pt = clickToPdfPt(px, py, box.width, box.height, slot.size);
-                const hit = session.positionAt(slot.page, pt.x, pt.y);
+                const tol = pxToPt(CLICK_SLACK_PX, box.width, slot.size);
+                const hit = session.positionAt(slot.page, pt.x, pt.y, tol);
                 if (hit)
                     return void onPick(hit);
-                const field = session.fieldAt(slot.page, pt.x, pt.y);
+                const field = session.fieldAt(slot.page, pt.x, pt.y, tol);
                 if (field)
                     onPick({ field });
             };
@@ -72,52 +79,50 @@ export function createBridge(session, container, slots, onPick) {
         marker.remove();
         return rect;
     }
-    // Centre `target` vertically in the scrollport; the cross axis takes the minimum
-    // trip instead, since the container is a vertical scroller and only a page wider
-    // than the port has anything to move there.
-    function centre(target) {
-        const port = container.getBoundingClientRect();
+    // Centre `target` vertically in `port`, the scrollport's box; the cross axis takes the
+    // minimum trip instead, since the container is a vertical scroller and only a page
+    // wider than the port has anything to move there. `port` is the caller's own read: the
+    // marker `measure` places is absolute inside the slot, so nothing between that read
+    // and this one moves the container's box, and one forced layout serves the whole hop.
+    function centre(target, port) {
         container.scrollTop += target.top + target.height / 2 - (port.top + port.height / 2);
         if (target.left < port.left)
             container.scrollLeft += target.left - port.left;
         else if (target.right > port.right)
             container.scrollLeft += target.right - port.right;
     }
-    // The trip a pane with no box could not run, held for the box coming back. One, and
-    // the last one asked for: a caret hop supersedes the hop before it on a showing pane
-    // too.
-    let held;
     // The re-assert. Nothing else asks on the way back: `refresh` re-asks only on a
     // recompile, and the reader who has just tapped Preview is not typing, so the pane
     // would open where the caret was several edits ago. Guarded for jsdom, which ships no
     // ResizeObserver and lays out nothing for one to report.
     if (typeof ResizeObserver !== 'undefined') {
         const observer = new ResizeObserver(() => {
-            if (!held || !hasBox(container.getBoundingClientRect()))
+            if (!held.run || !hasBox(container.getBoundingClientRect()))
                 return;
-            const trip = held;
-            held = undefined;
+            const trip = held.run;
+            held.run = undefined;
             trip();
         });
         observer.observe(container);
         unlisten.push(() => observer.disconnect());
     }
     function scrollToField(field) {
-        const box = boxesForField(field, session.fieldBoxes(field), session.regions())[0];
+        const box = boxesForField(field, session.fieldBoxes(field), () => session.regions())[0];
         if (!box)
             return false;
         const slot = slots[box.page];
         if (!slot)
             return false;
+        const port = container.getBoundingClientRect();
         // The address is placed, which is the whole of what the `boolean` answers; a pane
         // with no box yet is not a second no.
-        if (!hasBox(container.getBoundingClientRect())) {
-            held = () => void scrollToField(field);
+        if (!hasBox(port)) {
+            held.run = () => void scrollToField(field);
             return true;
         }
         // A discrete act ("show me this field"), so it centres every time, unlike
         // the continuous hop below.
-        centre(measure(slot, rectToPercent(box.rect, slot.size)));
+        centre(measure(slot, rectToPercent(box.rect, slot.size)), port);
         return true;
     }
     function focusPosition(field, pos) {
@@ -131,8 +136,9 @@ export function createBridge(session, container, slots, onPick) {
         // for every keystroke of (`hasBox`): the follow would die silently for as long as
         // a track is hidden. What is held is the request, not the trip, so it re-locates
         // against whatever compile is current when the pane comes back.
-        if (!hasBox(container.getBoundingClientRect())) {
-            held = () => focusPosition(field, pos);
+        const port = container.getBoundingClientRect();
+        if (!hasBox(port)) {
+            held.run = () => focusPosition(field, pos);
             return;
         }
         // The continuous hop: one call per keystroke and per arrow key, so it moves
@@ -140,9 +146,9 @@ export function createBridge(session, container, slots, onPick) {
         // takes the scrollport back from the user on every one of them, including
         // the ones that changed nothing about where the caret already was.
         const target = measure(slot, rectToPercent(region.rect, slot.size));
-        if (clearOfTheFold(target, container.getBoundingClientRect()))
+        if (clearOfTheFold(target, port))
             return;
-        centre(target);
+        centre(target, port);
     }
     return {
         scrollToField,

package/dist/preview/controller.js

@@ -7,14 +7,13 @@ const CONTAINER_CLASS = 'qm-preview';
 // class, the hooks a consumer and the tests target.
 const MESSAGE_CLASS = 'qm-preview-message';
 const EMPTY_CLASS = 'qm-preview-empty';
-const UNSUPPORTED_CLASS = 'qm-preview-unsupported';
 const ERROR_CLASS = 'qm-preview-error';
 export function createPreview(session, opts) {
     const container = opts.container;
     const margin = opts.margin ?? 1;
     const t = mergePreviewStrings(opts.strings);
     container.classList.add(CONTAINER_CLASS);
-    // One element, restamped: the non-paint states (empty, unsupported, a paint that
+    // One element, restamped: the non-paint states (empty, a paint that
     // threw) are mutually exclusive.
     let message;
     function showMessage(text, state) {
@@ -33,8 +32,8 @@ export function createPreview(session, opts) {
     // slots and never calls the `paint`/`pageSize` verbs the boundary refuses
     // there. A paint that unexpectedly throws is caught per-slot and surfaced
     // through the shared message rather than aborting the observer callback
-    // mid-sweep (runtime.d.ts: even a `supportsCanvas` compile can hit a paint
-    // the boundary refuses; brittle to leave uncaught).
+    // mid-sweep (a paint is the one surface that can still refuse a counted page;
+    // brittle to leave uncaught).
     const paintLoop = createPaintLoop(session, container, margin, (page, err) => {
         reportError(opts.onError, {
             code: 'paint-failed',
@@ -50,24 +49,25 @@ export function createPreview(session, opts) {
     // slots array is a stable identity but its members are swapped on reconcile, and
     // the listeners are per slot.
     let bridge;
+    // Outlives that rebuild, so a trip held for a pane with no box crosses it. Only the
+    // follow is re-asserted after a recompile, and a `scrollToField` the pane could not
+    // run has nothing else that would ask again for it.
+    const held = {};
     function attach() {
-        bridge = createBridge(session, container, paintLoop.slots, opts.onPick);
+        bridge = createBridge(session, container, paintLoop.slots, opts.onPick, held);
     }
     function detach() {
         bridge?.destroy();
         bridge = undefined;
     }
-    // Called at construction and after every `apply`, so `supportsCanvas` is re-read
-    // per compile (runtime.d.ts: re-check after `open`) and a 0-page or non-canvas
-    // compile that later gains paintable pages recovers; the check spans the paint
-    // capability generally, not just the page count.
+    // Called at construction and after every `apply`, so a 0-page compile that later
+    // gains pages recovers. A counted page is the whole condition: every backend
+    // paints, and `paint`/`pageSize` refuse only a page the count excludes.
     function render(pageCount, dirtyPages) {
-        if (!session.supportsCanvas || pageCount === 0) {
-            // A 0-page compile is a recoverable empty; pages the boundary cannot
-            // raster are a genuine unsupported.
+        if (pageCount === 0) {
             paintLoop.refresh([], 0);
             detach();
-            showMessage(pageCount === 0 ? t.noPages : t.unsupported, pageCount === 0 ? EMPTY_CLASS : UNSUPPORTED_CLASS);
+            showMessage(t.noPages, EMPTY_CLASS);
             return;
         }
         // Read the count against the current slots before reconcile moves it, and

package/dist/preview/geometry.d.ts

@@ -27,8 +27,11 @@ export interface PdfPoint {
  * boundary character (`.` for a nested field, `[` for an array element) keeps the
  * prefix a path boundary: `main.keywords` matches `main.keywords[0]`, not
  * `main.keywords_note`.
+ *
+ * `regions` is a thunk because the first rung answers without it, and taking it
+ * marshals every placement in the compile across the WASM boundary.
  */
-export declare function boxesForField(field: string, boxes: readonly FieldRegion[], regions: readonly FieldRegion[]): readonly FieldRegion[];
+export declare function boxesForField(field: string, boxes: readonly FieldRegion[], regions: () => readonly FieldRegion[]): readonly FieldRegion[];
 /**
  * Forward: a PDF-pt rect -> CSS % of the page box. Percent positioning tracks
  * the page's displayed size across DPR and container resize for free, so the
@@ -41,6 +44,14 @@ export declare function rectToPercent(rect: PdfRect, pageSize: PageSize): Percen
  * the transform that produces it rather than at the caller placing a marker.
  */
 export declare function applyPercentRect(el: HTMLElement, pct: PercentRect): void;
+/**
+ * A CSS-px length on a page element of CSS width `cssW` -> the PDF-pt length it spans.
+ * Width alone, because that is the scale the slot is drawn at: `paint.ts` sizes a slot
+ * by width under a locked aspect ratio, so {@link clickToPdfPt}'s two ratios are one
+ * number and a length has one to convert through. What the click bridge reads its
+ * pointer slack in points through.
+ */
+export declare function pxToPt(px: number, cssW: number, pageSize: PageSize): number;
 /**
  * Inverse: a click at CSS px `(px, py)` within a page element of CSS size
  * `(cssW, cssH)` -> PDF-pt. The exact inverse of {@link rectToPercent}: the

package/dist/preview/geometry.js

@@ -12,11 +12,14 @@
  * boundary character (`.` for a nested field, `[` for an array element) keeps the
  * prefix a path boundary: `main.keywords` matches `main.keywords[0]`, not
  * `main.keywords_note`.
+ *
+ * `regions` is a thunk because the first rung answers without it, and taking it
+ * marshals every placement in the compile across the WASM boundary.
  */
 export function boxesForField(field, boxes, regions) {
     if (boxes.length)
         return boxes;
-    return regions.filter((r) => r.field === field || r.field.startsWith(`${field}.`) || r.field.startsWith(`${field}[`));
+    return regions().filter((r) => r.field === field || r.field.startsWith(`${field}.`) || r.field.startsWith(`${field}[`));
 }
 /**
  * Forward: a PDF-pt rect -> CSS % of the page box. Percent positioning tracks
@@ -47,6 +50,16 @@ export function applyPercentRect(el, pct) {
         height: `${pct.height}%`
     });
 }
+/**
+ * A CSS-px length on a page element of CSS width `cssW` -> the PDF-pt length it spans.
+ * Width alone, because that is the scale the slot is drawn at: `paint.ts` sizes a slot
+ * by width under a locked aspect ratio, so {@link clickToPdfPt}'s two ratios are one
+ * number and a length has one to convert through. What the click bridge reads its
+ * pointer slack in points through.
+ */
+export function pxToPt(px, cssW, pageSize) {
+    return (px / cssW) * pageSize.widthPt;
+}
 /**
  * Inverse: a click at CSS px `(px, py)` within a page element of CSS size
  * `(cssW, cssH)` -> PDF-pt. The exact inverse of {@link rectToPercent}: the

package/dist/preview/paint.js

@@ -41,7 +41,11 @@ onPaintError) {
         // responsibilities"). `border-box` costs nothing here and keeps a slot a
         // consumer insets from measuring wider than its paper.
         const el = document.createElement('div');
-        el.className = 'qm-page';
+        // Not `.qm-page`: that name is the preset's page baseline, an unlayered rule at
+        // ordinary specificity a host puts on `<body>`, and a slot wearing it takes that
+        // rule's `color-scheme` inside a mounted root, which the derivation leaves to the
+        // host (`core/theme.css`).
+        el.className = 'qm-page-slot';
         // The page's index, in the DOM. `pageByEl` is this module's and a consumer
         // drawing an overlay of its own needs the number: position among siblings is
         // the only handle without it, which is right today and is not a contract.
@@ -157,9 +161,7 @@ onPaintError) {
     }
     // Slots are built on the first `refresh` (the controller calls it immediately),
     // not here: reconcile → `session.pageSize` must run after the controller's
-    // `supportsCanvas`/`pageCount` gate, since a `supportsCanvas: false` compile with
-    // pages would throw on `pageSize` (runtime.d.ts: it succeeds iff `supportsCanvas`)
-    // before the controller can surface its "unsupported" message.
+    // `pageCount` gate, since `pageSize` throws for a page the count excludes.
     // ── Keep mounted rasters in step with the display ───────────────────────────
     // Every paint freezes `canvas.style.width/height` to the box width at that
     // paint (paintSlot). A page that stays mounted while the container's CSS width

package/dist/preview/strings.d.ts

@@ -3,8 +3,6 @@ export interface PreviewStrings {
     renderFailed: string;
     /** A compile with zero pages: recoverable, and the commonest state of a fresh seed. */
     noPages: string;
-    /** A compile whose pages this backend cannot raster at all. */
-    unsupported: string;
 }
 /** The package's English. Every key, so the merge below is total. */
 export declare const DEFAULT_PREVIEW_STRINGS: PreviewStrings;

package/dist/preview/strings.js

@@ -1,5 +1,5 @@
-// Every word the preview says. Three, because the surface is a canvas and its
-// only prose is the message states that stand in when there is nothing to paint.
+// Every word the preview says: the surface is a canvas, and its only prose is the
+// message states that stand in when there is nothing to paint.
 //
 // Separate from the visual surface's set rather than pooled with it: `/preview`
 // reaches `/core` and nothing editor-side, which is what lets it promote to its own
@@ -8,13 +8,12 @@
 // twice rather than learning two idioms.
 //
 // A plain options field rather than a context channel, unlike the visual surface's:
-// these three are read in one module by one function, so there is no tree to make
-// them ambient for.
+// they are read in one module by one function, so there is no tree to make them
+// ambient for.
 /** The package's English. Every key, so the merge below is total. */
 export const DEFAULT_PREVIEW_STRINGS = {
     renderFailed: 'Preview failed to render.',
-    noPages: 'No pages to preview.',
-    unsupported: 'Preview is not available for this document.'
+    noPages: 'No pages to preview.'
 };
 /** Fill a partial override to the whole key set. */
 export function mergePreviewStrings(custom) {