fundus 0.0.2 → 0.0.3

package/dist/runtime/components/SliceCanvas.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { SliceManifestEntry } from '../../core/index.js';
+interface Props {
+    src: SliceManifestEntry;
+    /** Accessible label for the rendered graphic. */
+    alt?: string;
+    class?: string;
+}
+declare const SliceCanvas: import("svelte").Component<Props, {}, "">;
+type SliceCanvas = ReturnType<typeof SliceCanvas>;
+export default SliceCanvas;

package/dist/runtime/components/SliceDom.svelte

@@ -15,9 +15,9 @@
 	layout box.
 -->
 <script lang="ts">
-	import type { SliceManifestEntry } from '#fundus/core';
-	import { computeRenderCells, effectiveOverdraw } from '../geometry';
-	import { observeBorderBoxSize } from '../observe-border-box-size';
+	import type { SliceManifestEntry } from '../../core/index.js';
+	import { computeRenderCells, effectiveOverdraw } from '../geometry.js';
+	import { observeBorderBoxSize } from '../observe-border-box-size.js';
 
 	interface Props {
 		src: SliceManifestEntry;

package/dist/runtime/components/SliceDom.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { SliceManifestEntry } from '../../core/index.js';
+interface Props {
+    src: SliceManifestEntry;
+    /** Accessible label for the rendered graphic. */
+    alt?: string;
+    class?: string;
+}
+declare const SliceDom: import("svelte").Component<Props, {}, "">;
+type SliceDom = ReturnType<typeof SliceDom>;
+export default SliceDom;

package/dist/runtime/components/Video.svelte

@@ -5,8 +5,8 @@
 	where and how it plays is host behavior, so loop/playing/muted/controls stay props.
 -->
 <script lang="ts">
-	import type { VideoManifestEntry } from '#fundus/core';
-	import { resolveRetainedSource } from '../preload-registry';
+	import type { VideoManifestEntry } from '../../core/index.js';
+	import { resolveRetainedSource } from '../preload-registry.js';
 
 	interface Props {
 		src: VideoManifestEntry;

package/dist/runtime/components/Video.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { VideoManifestEntry } from '../../core/index.js';
+interface Props {
+    src: VideoManifestEntry;
+    /** Loop playback (default false — a plain clip ends unless the host says otherwise). */
+    loop?: boolean;
+    /** Playback on/off (default true). */
+    playing?: boolean;
+    /** Muted (default true — required for autoplay in every mobile browser). */
+    muted?: boolean;
+    /** Show native playback controls (default false). */
+    controls?: boolean;
+    /** Bindable handle on the underlying element, so a host can drive playback itself. */
+    videoElement?: HTMLVideoElement;
+    class?: string;
+}
+declare const Video: import("svelte").Component<Props, {}, "videoElement">;
+type Video = ReturnType<typeof Video>;
+export default Video;

package/dist/runtime/geometry.d.ts

@@ -1,31 +1,53 @@
-import { SliceInsets, SliceManifestEntry } from "#fundus/core";
-
-//#region src/geometry.d.ts
+/**
+ * Pure slice geometry operating on a `SliceManifestEntry` (slicing + source
+ * dimensions). Given an entry and the box (container) size in
+ * CSS pixels, it returns the cells to paint — each with its SOURCE rect
+ * (pixels, for sampling the image) and DEST rect (CSS pixels within the box).
+ * One function covers all modes:
+ *
+ * - `nine`             — corners are fixed at their logical size (inset ÷
+ *   pixelRatio); edges stretch one axis, the center stretches both.
+ * - `three-horizontal` — left/right caps fill the box height (cross axis) keeping
+ *   their aspect ratio (so they scale with the box); the center stretches across
+ *   the remaining width.
+ * - `three-vertical`   — top/bottom caps fill the box width keeping their aspect
+ *   ratio; the middle stretches down the remaining height.
+ * - `one`              — no slicing: the whole image is one cell stretched to
+ *   fill the box on both axes (per-axis scale, like a plain `<img>`).
+ *
+ * **Overdraw** (`slicing.overdraw`): a baked-in drop shadow / glow band around
+ * the actual element. The image minus the overdraw is the element core; the core
+ * fills the layout box and the overdraw is painted outside it. Implemented by
+ * rendering into a virtual box expanded by the overdraw's destination size on
+ * each side and shifting every cell back by that amount — so cells can have
+ * negative `dx`/`dy` and extend past the box (like a CSS `box-shadow`).
+ */
+import type { SliceInsets, SliceManifestEntry } from '../core/index.js';
 /** One cell to paint: a source rect (px) drawn into a dest rect (CSS px). */
-interface RenderCell {
-  key: string;
-  /** Source rect, in source pixels. */
-  sx: number;
-  sy: number;
-  sw: number;
-  sh: number;
-  /** Destination rect within the box, in CSS pixels (integers, abutting). */
-  dx: number;
-  dy: number;
-  dw: number;
-  dh: number;
+export interface RenderCell {
+    key: string;
+    /** Source rect, in source pixels. */
+    sx: number;
+    sy: number;
+    sw: number;
+    sh: number;
+    /** Destination rect within the box, in CSS pixels (integers, abutting). */
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
 }
 /**
  * The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
  * the axis it does not use (and `one` uses none at all), so callers never have
  * to special-case the mode.
  */
-declare function effectiveInsets(entry: SliceManifestEntry): SliceInsets;
+export declare function effectiveInsets(entry: SliceManifestEntry): SliceInsets;
 /**
  * The overdraw that actually applies: zeros when absent, clamped so a core of at
  * least one source pixel remains on each axis.
  */
-declare function effectiveOverdraw(entry: SliceManifestEntry): SliceInsets;
+export declare function effectiveOverdraw(entry: SliceManifestEntry): SliceInsets;
 /**
  * The overdraw's per-side destination size in CSS pixels for a box — how far the
  * painted slice extends past the layout box on each side. Rounded to integers so
@@ -34,7 +56,7 @@ declare function effectiveOverdraw(entry: SliceManifestEntry): SliceInsets;
  * the caps: box cross-axis ÷ the layout box (image minus overdraw). In `one`
  * mode the image stretches per axis, so each axis scales independently.
  */
-declare function computeOverdrawDestination(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): SliceInsets;
+export declare function computeOverdrawDestination(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): SliceInsets;
 /**
  * How the canvas backend's `<canvas>` relates to the layout box: with overdraw
  * the canvas is enlarged by the overdraw's destination size and offset
@@ -44,32 +66,30 @@ declare function computeOverdrawDestination(entry: SliceManifestEntry, boxWidth:
  * origin sits at the layout box's top-left in device pixels — so the (possibly
  * negative) cell coordinates from `computeRenderCells` apply directly.
  */
-interface CanvasPaintLayout {
-  /** CSS offset of the canvas within the wrapper (0 or negative — overdraw). */
-  cssLeft: number;
-  cssTop: number;
-  /** CSS size of the canvas (box expanded by the overdraw's destination size). */
-  cssWidth: number;
-  cssHeight: number;
-  /** Backing-store size in device pixels (CSS size × devicePixelRatio). */
-  backingWidth: number;
-  backingHeight: number;
-  /** Paint origin (the layout box's top-left) in device pixels. */
-  originX: number;
-  originY: number;
+export interface CanvasPaintLayout {
+    /** CSS offset of the canvas within the wrapper (0 or negative — overdraw). */
+    cssLeft: number;
+    cssTop: number;
+    /** CSS size of the canvas (box expanded by the overdraw's destination size). */
+    cssWidth: number;
+    cssHeight: number;
+    /** Backing-store size in device pixels (CSS size × devicePixelRatio). */
+    backingWidth: number;
+    backingHeight: number;
+    /** Paint origin (the layout box's top-left) in device pixels. */
+    originX: number;
+    originY: number;
 }
 /**
  * The canvas geometry for a slice filling a `boxWidth × boxHeight` layout box
  * at the given `devicePixelRatio` (the display's, not the asset's export
  * scale). Pure — the canvas backend derives every size and offset from this.
  */
-declare function computeCanvasPaintLayout(entry: SliceManifestEntry, boxWidth: number, boxHeight: number, devicePixelRatio: number): CanvasPaintLayout;
+export declare function computeCanvasPaintLayout(entry: SliceManifestEntry, boxWidth: number, boxHeight: number, devicePixelRatio: number): CanvasPaintLayout;
 /**
  * Compute the cells to paint for a slice filling a `boxWidth × boxHeight` box.
  * Returns an empty array for a zero-size box. With overdraw the cells cover the
  * box expanded by `computeOverdrawDestination` on each side, so `dx`/`dy` can be
  * negative and cells can extend past the box.
  */
-declare function computeRenderCells(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): RenderCell[];
-//#endregion
-export { CanvasPaintLayout, RenderCell, computeCanvasPaintLayout, computeOverdrawDestination, computeRenderCells, effectiveInsets, effectiveOverdraw };
+export declare function computeRenderCells(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): RenderCell[];

package/dist/runtime/geometry.js

@@ -1,209 +1,204 @@
-import { createZeroInsets, slicedAxesFor } from "#fundus/core";
-//#region src/geometry.ts
+import { createZeroInsets, slicedAxesFor } from '../core/index.js';
 function clamp(value, min, max) {
-	return Math.max(min, Math.min(max, value));
+    return Math.max(min, Math.min(max, value));
 }
 /**
-* The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
-* the axis it does not use (and `one` uses none at all), so callers never have
-* to special-case the mode.
-*/
-function effectiveInsets(entry) {
-	const { mode, insets } = entry.slicing;
-	const axes = slicedAxesFor(mode);
-	return {
-		top: axes.vertical ? insets.top : 0,
-		bottom: axes.vertical ? insets.bottom : 0,
-		left: axes.horizontal ? insets.left : 0,
-		right: axes.horizontal ? insets.right : 0
-	};
+ * The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
+ * the axis it does not use (and `one` uses none at all), so callers never have
+ * to special-case the mode.
+ */
+export function effectiveInsets(entry) {
+    const { mode, insets } = entry.slicing;
+    const axes = slicedAxesFor(mode);
+    return {
+        top: axes.vertical ? insets.top : 0,
+        bottom: axes.vertical ? insets.bottom : 0,
+        left: axes.horizontal ? insets.left : 0,
+        right: axes.horizontal ? insets.right : 0
+    };
 }
 /**
-* The overdraw that actually applies: zeros when absent, clamped so a core of at
-* least one source pixel remains on each axis.
-*/
-function effectiveOverdraw(entry) {
-	const overdraw = entry.slicing.overdraw;
-	if (!overdraw) return createZeroInsets();
-	const width = entry.sourceWidth;
-	const height = entry.sourceHeight;
-	const left = clamp(overdraw.left, 0, Math.max(0, width - 1));
-	const right = clamp(overdraw.right, 0, Math.max(0, width - left - 1));
-	const top = clamp(overdraw.top, 0, Math.max(0, height - 1));
-	return {
-		top,
-		right,
-		bottom: clamp(overdraw.bottom, 0, Math.max(0, height - top - 1)),
-		left
-	};
+ * The overdraw that actually applies: zeros when absent, clamped so a core of at
+ * least one source pixel remains on each axis.
+ */
+export function effectiveOverdraw(entry) {
+    const overdraw = entry.slicing.overdraw;
+    if (!overdraw)
+        return createZeroInsets();
+    // Mirrors core's authoring `maxOverdraw` bound; this survives hand-edited libraries.
+    const width = entry.sourceWidth;
+    const height = entry.sourceHeight;
+    const left = clamp(overdraw.left, 0, Math.max(0, width - 1));
+    const right = clamp(overdraw.right, 0, Math.max(0, width - left - 1));
+    const top = clamp(overdraw.top, 0, Math.max(0, height - 1));
+    const bottom = clamp(overdraw.bottom, 0, Math.max(0, height - top - 1));
+    return { top, right, bottom, left };
 }
 /**
-* The layout box — the image minus its effective overdraw — in **source pixels**
-* Never smaller than one source pixel per axis (`effectiveOverdraw` guarantees
-* a remaining box).
-*/
+ * The layout box — the image minus its effective overdraw — in **source pixels**
+ * Never smaller than one source pixel per axis (`effectiveOverdraw` guarantees
+ * a remaining box).
+ */
 function sourceLayoutSize(entry) {
-	const overdraw = effectiveOverdraw(entry);
-	return {
-		width: Math.max(1, entry.sourceWidth - overdraw.left - overdraw.right),
-		height: Math.max(1, entry.sourceHeight - overdraw.top - overdraw.bottom)
-	};
+    const overdraw = effectiveOverdraw(entry);
+    return {
+        width: Math.max(1, entry.sourceWidth - overdraw.left - overdraw.right),
+        height: Math.max(1, entry.sourceHeight - overdraw.top - overdraw.bottom)
+    };
 }
 /**
-* The overdraw's per-side destination size in CSS pixels for a box — how far the
-* painted slice extends past the layout box on each side. Rounded to integers so
-* cells keep abutting on integer pixels. For a 9-slice the overdraw is a fixed
-* band (÷ `pixelRatio`, like the corners); for the 3-slice modes it scales with
-* the caps: box cross-axis ÷ the layout box (image minus overdraw). In `one`
-* mode the image stretches per axis, so each axis scales independently.
-*/
-function computeOverdrawDestination(entry, boxWidth, boxHeight) {
-	const overdraw = effectiveOverdraw(entry);
-	if (overdraw.top === 0 && overdraw.right === 0 && overdraw.bottom === 0 && overdraw.left === 0) return overdraw;
-	const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
-	const sourceLayout = sourceLayoutSize(entry);
-	let horizontalScale;
-	let verticalScale;
-	if (entry.slicing.mode === "three-horizontal") horizontalScale = verticalScale = boxHeight / sourceLayout.height;
-	else if (entry.slicing.mode === "three-vertical") horizontalScale = verticalScale = boxWidth / sourceLayout.width;
-	else if (entry.slicing.mode === "one") {
-		horizontalScale = boxWidth / sourceLayout.width;
-		verticalScale = boxHeight / sourceLayout.height;
-	} else horizontalScale = verticalScale = 1 / pixelRatio;
-	return {
-		top: Math.round(overdraw.top * verticalScale),
-		right: Math.round(overdraw.right * horizontalScale),
-		bottom: Math.round(overdraw.bottom * verticalScale),
-		left: Math.round(overdraw.left * horizontalScale)
-	};
+ * The overdraw's per-side destination size in CSS pixels for a box — how far the
+ * painted slice extends past the layout box on each side. Rounded to integers so
+ * cells keep abutting on integer pixels. For a 9-slice the overdraw is a fixed
+ * band (÷ `pixelRatio`, like the corners); for the 3-slice modes it scales with
+ * the caps: box cross-axis ÷ the layout box (image minus overdraw). In `one`
+ * mode the image stretches per axis, so each axis scales independently.
+ */
+export function computeOverdrawDestination(entry, boxWidth, boxHeight) {
+    const overdraw = effectiveOverdraw(entry);
+    if (overdraw.top === 0 && overdraw.right === 0 && overdraw.bottom === 0 && overdraw.left === 0) {
+        return overdraw;
+    }
+    const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
+    const sourceLayout = sourceLayoutSize(entry);
+    let horizontalScale;
+    let verticalScale;
+    if (entry.slicing.mode === 'three-horizontal') {
+        horizontalScale = verticalScale = boxHeight / sourceLayout.height;
+    }
+    else if (entry.slicing.mode === 'three-vertical') {
+        horizontalScale = verticalScale = boxWidth / sourceLayout.width;
+    }
+    else if (entry.slicing.mode === 'one') {
+        horizontalScale = boxWidth / sourceLayout.width;
+        verticalScale = boxHeight / sourceLayout.height;
+    }
+    else {
+        horizontalScale = verticalScale = 1 / pixelRatio;
+    }
+    return {
+        top: Math.round(overdraw.top * verticalScale),
+        right: Math.round(overdraw.right * horizontalScale),
+        bottom: Math.round(overdraw.bottom * verticalScale),
+        left: Math.round(overdraw.left * horizontalScale)
+    };
 }
 /**
-* The canvas geometry for a slice filling a `boxWidth × boxHeight` layout box
-* at the given `devicePixelRatio` (the display's, not the asset's export
-* scale). Pure — the canvas backend derives every size and offset from this.
-*/
-function computeCanvasPaintLayout(entry, boxWidth, boxHeight, devicePixelRatio) {
-	const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
-	const cssWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
-	const cssHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
-	return {
-		cssLeft: -overdrawDestination.left + 0,
-		cssTop: -overdrawDestination.top + 0,
-		cssWidth,
-		cssHeight,
-		backingWidth: Math.round(cssWidth * devicePixelRatio),
-		backingHeight: Math.round(cssHeight * devicePixelRatio),
-		originX: overdrawDestination.left * devicePixelRatio,
-		originY: overdrawDestination.top * devicePixelRatio
-	};
+ * The canvas geometry for a slice filling a `boxWidth × boxHeight` layout box
+ * at the given `devicePixelRatio` (the display's, not the asset's export
+ * scale). Pure — the canvas backend derives every size and offset from this.
+ */
+export function computeCanvasPaintLayout(entry, boxWidth, boxHeight, devicePixelRatio) {
+    const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
+    const cssWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
+    const cssHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
+    return {
+        // `+ 0` normalizes the negative zero a zero overdraw would produce.
+        cssLeft: -overdrawDestination.left + 0,
+        cssTop: -overdrawDestination.top + 0,
+        cssWidth,
+        cssHeight,
+        backingWidth: Math.round(cssWidth * devicePixelRatio),
+        backingHeight: Math.round(cssHeight * devicePixelRatio),
+        originX: overdrawDestination.left * devicePixelRatio,
+        originY: overdrawDestination.top * devicePixelRatio
+    };
 }
 /** Cumulative, rounded edges so adjacent cells abut exactly on integer pixels. */
 function cumulativeEdges(sizes) {
-	let accumulated = 0;
-	const edges = [0];
-	for (const size of sizes) {
-		accumulated += size;
-		edges.push(Math.round(accumulated));
-	}
-	return edges;
+    let accumulated = 0;
+    const edges = [0];
+    for (const size of sizes) {
+        accumulated += size;
+        edges.push(Math.round(accumulated));
+    }
+    return edges;
 }
 /**
-* Compute the cells to paint for a slice filling a `boxWidth × boxHeight` box.
-* Returns an empty array for a zero-size box. With overdraw the cells cover the
-* box expanded by `computeOverdrawDestination` on each side, so `dx`/`dy` can be
-* negative and cells can extend past the box.
-*/
-function computeRenderCells(entry, boxWidth, boxHeight) {
-	if (boxWidth <= 0 || boxHeight <= 0) return [];
-	const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
-	const paintWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
-	const paintHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
-	const width = entry.sourceWidth;
-	const height = entry.sourceHeight;
-	const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
-	const mode = entry.slicing.mode;
-	const insets = effectiveInsets(entry);
-	const left = clamp(insets.left, 0, width);
-	const right = clamp(insets.right, 0, Math.max(0, width - left));
-	const top = clamp(insets.top, 0, height);
-	const bottom = clamp(insets.bottom, 0, Math.max(0, height - top));
-	const centerWidth = Math.max(0, width - left - right);
-	const centerHeight = Math.max(0, height - top - bottom);
-	let leftDestination;
-	let rightDestination;
-	if (mode === "three-horizontal") {
-		const scale = paintHeight / height;
-		leftDestination = left * scale;
-		rightDestination = right * scale;
-	} else {
-		leftDestination = left / pixelRatio;
-		rightDestination = right / pixelRatio;
-	}
-	const centerDestinationWidth = Math.max(0, paintWidth - leftDestination - rightDestination);
-	let topDestination;
-	let bottomDestination;
-	if (mode === "three-vertical") {
-		const scale = paintWidth / width;
-		topDestination = top * scale;
-		bottomDestination = bottom * scale;
-	} else {
-		topDestination = top / pixelRatio;
-		bottomDestination = bottom / pixelRatio;
-	}
-	const centerDestinationHeight = Math.max(0, paintHeight - topDestination - bottomDestination);
-	const sourceColumns = [
-		left,
-		centerWidth,
-		right
-	];
-	const sourceRows = [
-		top,
-		centerHeight,
-		bottom
-	];
-	const sourceColumnStarts = [
-		0,
-		left,
-		left + centerWidth
-	];
-	const sourceRowStarts = [
-		0,
-		top,
-		top + centerHeight
-	];
-	const columnEdges = cumulativeEdges([
-		leftDestination,
-		centerDestinationWidth,
-		rightDestination
-	]);
-	const rowEdges = cumulativeEdges([
-		topDestination,
-		centerDestinationHeight,
-		bottomDestination
-	]);
-	const cells = [];
-	for (let row = 0; row < 3; row++) for (let column = 0; column < 3; column++) {
-		const sw = sourceColumns[column];
-		const sh = sourceRows[row];
-		if (sw <= 0 || sh <= 0) continue;
-		const dx = columnEdges[column];
-		const dw = columnEdges[column + 1] - dx;
-		const dy = rowEdges[row];
-		const dh = rowEdges[row + 1] - dy;
-		if (dw <= 0 || dh <= 0) continue;
-		cells.push({
-			key: `${row}-${column}`,
-			sx: sourceColumnStarts[column],
-			sy: sourceRowStarts[row],
-			sw,
-			sh,
-			dx: dx - overdrawDestination.left,
-			dy: dy - overdrawDestination.top,
-			dw,
-			dh
-		});
-	}
-	return cells;
+ * Compute the cells to paint for a slice filling a `boxWidth × boxHeight` box.
+ * Returns an empty array for a zero-size box. With overdraw the cells cover the
+ * box expanded by `computeOverdrawDestination` on each side, so `dx`/`dy` can be
+ * negative and cells can extend past the box.
+ */
+export function computeRenderCells(entry, boxWidth, boxHeight) {
+    if (boxWidth <= 0 || boxHeight <= 0)
+        return [];
+    // Render into a virtual box expanded by the overdraw, then shift every cell
+    // back so the element core lands exactly in the layout box.
+    const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
+    const paintWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
+    const paintHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
+    const width = entry.sourceWidth;
+    const height = entry.sourceHeight;
+    const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
+    const mode = entry.slicing.mode;
+    const insets = effectiveInsets(entry);
+    const left = clamp(insets.left, 0, width);
+    const right = clamp(insets.right, 0, Math.max(0, width - left));
+    const top = clamp(insets.top, 0, height);
+    const bottom = clamp(insets.bottom, 0, Math.max(0, height - top));
+    const centerWidth = Math.max(0, width - left - right);
+    const centerHeight = Math.max(0, height - top - bottom);
+    // Horizontal dest sizes for [left, center, right].
+    let leftDestination;
+    let rightDestination;
+    if (mode === 'three-horizontal') {
+        // Caps fill the box height (cross axis), scaling uniformly to keep aspect.
+        const scale = paintHeight / height;
+        leftDestination = left * scale;
+        rightDestination = right * scale;
+    }
+    else {
+        // 9-slice: fixed corners at logical size. three-vertical: left = right = 0.
+        leftDestination = left / pixelRatio;
+        rightDestination = right / pixelRatio;
+    }
+    const centerDestinationWidth = Math.max(0, paintWidth - leftDestination - rightDestination);
+    // Vertical dest sizes for [top, center, bottom].
+    let topDestination;
+    let bottomDestination;
+    if (mode === 'three-vertical') {
+        // Caps fill the box width (cross axis), scaling uniformly to keep aspect.
+        const scale = paintWidth / width;
+        topDestination = top * scale;
+        bottomDestination = bottom * scale;
+    }
+    else {
+        topDestination = top / pixelRatio;
+        bottomDestination = bottom / pixelRatio;
+    }
+    const centerDestinationHeight = Math.max(0, paintHeight - topDestination - bottomDestination);
+    const sourceColumns = [left, centerWidth, right];
+    const sourceRows = [top, centerHeight, bottom];
+    const sourceColumnStarts = [0, left, left + centerWidth];
+    const sourceRowStarts = [0, top, top + centerHeight];
+    const columnEdges = cumulativeEdges([leftDestination, centerDestinationWidth, rightDestination]);
+    const rowEdges = cumulativeEdges([topDestination, centerDestinationHeight, bottomDestination]);
+    const cells = [];
+    for (let row = 0; row < 3; row++) {
+        for (let column = 0; column < 3; column++) {
+            const sw = sourceColumns[column];
+            const sh = sourceRows[row];
+            if (sw <= 0 || sh <= 0)
+                continue;
+            const dx = columnEdges[column];
+            const dw = columnEdges[column + 1] - dx;
+            const dy = rowEdges[row];
+            const dh = rowEdges[row + 1] - dy;
+            if (dw <= 0 || dh <= 0)
+                continue;
+            cells.push({
+                key: `${row}-${column}`,
+                sx: sourceColumnStarts[column],
+                sy: sourceRowStarts[row],
+                sw,
+                sh,
+                dx: dx - overdrawDestination.left,
+                dy: dy - overdrawDestination.top,
+                dw,
+                dh
+            });
+        }
+    }
+    return cells;
 }
-//#endregion
-export { computeCanvasPaintLayout, computeOverdrawDestination, computeRenderCells, effectiveInsets, effectiveOverdraw };

package/dist/runtime/index.d.ts

@@ -1,9 +1,9 @@
-import { Manifest, createManifest } from "./manifest.js";
-import { resolveRetainedSource } from "./preload-registry.js";
-import { audioSourceOf } from "./kind-handlers.js";
-import { AudioManifestEntry, AudioPreloadOptions, ChromaKeyParameters, ChromaKeyVideoManifestEntry, ChromaKeyVideoPreloadOptions, DEFAULT_CHROMA_KEY_PARAMETERS, ImageManifestEntry, ImagePreloadOptions, ManifestEntry, PreloadOptions, SliceManifestEntry, SlicePreloadOptions, VideoManifestEntry, VideoPreloadOptions } from "#fundus/core";
-import Image from "./components/Image.svelte";
-import Slice from "./components/Slice.svelte";
-import Video from "./components/Video.svelte";
-import ChromaKeyVideo from "./components/ChromaKeyVideo.svelte";
-export { type AudioManifestEntry, type AudioPreloadOptions, type ChromaKeyParameters, ChromaKeyVideo, type ChromaKeyVideoManifestEntry, type ChromaKeyVideoPreloadOptions, DEFAULT_CHROMA_KEY_PARAMETERS, Image, type ImageManifestEntry, type ImagePreloadOptions, Manifest, type ManifestEntry, type PreloadOptions, Slice, type SliceManifestEntry, type SlicePreloadOptions, Video, type VideoManifestEntry, type VideoPreloadOptions, audioSourceOf, createManifest, resolveRetainedSource };
+export { Manifest, createManifest } from './manifest.js';
+export { default as Image } from './components/Image.svelte';
+export { default as Slice } from './components/Slice.svelte';
+export { default as Video } from './components/Video.svelte';
+export { default as ChromaKeyVideo } from './components/ChromaKeyVideo.svelte';
+export { resolveRetainedSource } from './preload-registry.js';
+export { audioSourceOf } from './kind-handlers.js';
+export type { ImageManifestEntry, SliceManifestEntry, VideoManifestEntry, ChromaKeyVideoManifestEntry, AudioManifestEntry, ManifestEntry, ChromaKeyParameters, ImagePreloadOptions, SlicePreloadOptions, VideoPreloadOptions, ChromaKeyVideoPreloadOptions, AudioPreloadOptions, PreloadOptions } from '../core/index.js';
+export { DEFAULT_CHROMA_KEY_PARAMETERS } from '../core/index.js';