@texuli/core 0.5.0 → 0.6.0

package/dist/motion/spring.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Spring: a pure damped harmonic oscillator solver (ADR-013).
+ *
+ * Framework-free and DOM-free. The solver moves a normalized progress from 0
+ * to 1 with the closed form for every damping case (under, critical and over
+ * damped), finds when the spring settles, samples it into keyframe offsets or
+ * a CSS `linear()` easing, and reports position and velocity at any time so an
+ * interrupted animation can be retargeted without a velocity jump.
+ *
+ * Hostile inputs are clamped: stiffness, damping, mass, velocity and sample
+ * counts have fixed ranges, NaN falls back to the defaults, and the settle
+ * search never evaluates more than `MAX_SPRING_MS + 1` points.
+ */
+/** Physical spring parameters (unitless, like the CSS-in-JS spring convention). */
+export type SpringParams = {
+    /** Spring constant `k`. Clamped to [1, 10000]. */
+    readonly stiffness: number;
+    /** Damping coefficient `c`. Clamped to [0, 1000]. */
+    readonly damping: number;
+    /** Mass `m`. Clamped to [0.01, 1000]. */
+    readonly mass: number;
+};
+/** Options shared by the solver helpers. */
+export type SpringSolveOptions = {
+    /**
+     * Initial velocity in progress units per second (1 = the whole distance per
+     * second). Clamped to [-1000, 1000]. Default 0.
+     */
+    velocity?: number;
+    /** Settled when |1 − progress| is below this. Default 0.001. */
+    restDelta?: number;
+    /** Settled when |velocity| (progress per second) is below this. Default 0.01. */
+    restSpeed?: number;
+};
+/** Position and velocity of the spring at one time. */
+export type SpringState = {
+    /** Normalized progress (0 at rest start, 1 at the target; may overshoot). */
+    readonly position: number;
+    /** Progress units per second. */
+    readonly velocity: number;
+};
+/** Settle result. */
+export type SpringSettle = {
+    /** Milliseconds until the spring stays within rest thresholds, at most `MAX_SPRING_MS`. */
+    readonly durationMs: number;
+    /** False when the spring was still moving at `MAX_SPRING_MS` (the last frame snaps to 1). */
+    readonly settled: boolean;
+};
+/** Sampled spring curve. */
+export type SpringSamples = SpringSettle & {
+    /** Progress values at evenly spaced times from 0 to `durationMs`; first 0, last 1. */
+    readonly points: readonly number[];
+};
+/** Longest spring (and any Texuli motion) duration, in milliseconds. */
+export declare const MAX_SPRING_MS = 1000;
+/** Default sample count for keyframes and `linear()` easings. */
+export declare const DEFAULT_SPRING_SAMPLES = 40;
+/** Largest sample count accepted (keeps `linear()` strings short). */
+export declare const MAX_SPRING_SAMPLES = 120;
+/** Spring used when parameters are missing or not finite. */
+export declare const DEFAULT_SPRING: SpringParams;
+/** Clamp spring parameters into the supported ranges; NaN takes the default. */
+export declare function normalizeSpring(params: Partial<SpringParams> | null | undefined): SpringParams;
+/** Damping ratio ζ = c / (2√(k·m)); below 1 overshoots, 1 is critical. */
+export declare function dampingRatio(params: Partial<SpringParams>): number;
+/** Position and velocity `ms` milliseconds after release (closed form, O(1)). */
+export declare function springState(params: Partial<SpringParams>, ms: number, options?: SpringSolveOptions): SpringState;
+/**
+ * When the spring comes to rest: the first millisecond after which every
+ * sampled millisecond stays inside the rest thresholds. Bounded: at most
+ * `MAX_SPRING_MS + 1` closed-form evaluations.
+ */
+export declare function springSettle(params: Partial<SpringParams>, options?: SpringSolveOptions): SpringSettle;
+/**
+ * Sample the spring at evenly spaced times across its settle duration. The
+ * first point is the start position (0) and the last is pinned to 1, so a
+ * spring cut at `MAX_SPRING_MS` lands exactly on its target.
+ */
+export declare function springSamples(params: Partial<SpringParams>, options?: SpringSolveOptions & {
+    samples?: number;
+}): SpringSamples;
+/**
+ * A CSS `linear()` easing that traces the spring, with its duration. Points
+ * are evenly spaced, so no stop percentages are needed.
+ *
+ * @example
+ * const { easing, durationMs } = springEasing({ stiffness: 400, damping: 30, mass: 1 });
+ * element.animate(keyframes, { duration: durationMs, easing });
+ */
+export declare function springEasing(params: Partial<SpringParams>, options?: SpringSolveOptions & {
+    samples?: number;
+}): SpringSettle & {
+    readonly easing: string;
+};
+/**
+ * Keyframes for any property: `build(progress)` maps a spring position to a
+ * keyframe (for example a transform). Offsets are evenly spaced.
+ */
+export declare function springKeyframes(params: Partial<SpringParams>, build: (progress: number) => Keyframe, options?: SpringSolveOptions & {
+    samples?: number;
+}): SpringSettle & {
+    readonly keyframes: Keyframe[];
+};
+/**
+ * Velocity for a retargeted spring: a velocity measured in the old segment's
+ * progress units, converted to the new segment (`newSpan` / `oldSpan` are the
+ * distances in any shared unit). Zero or non-finite spans give 0.
+ */
+export declare function retargetVelocity(velocity: number, oldSpan: number, newSpan: number): number;

package/dist/motion/spring.js

@@ -0,0 +1,166 @@
+/**
+ * Spring: a pure damped harmonic oscillator solver (ADR-013).
+ *
+ * Framework-free and DOM-free. The solver moves a normalized progress from 0
+ * to 1 with the closed form for every damping case (under, critical and over
+ * damped), finds when the spring settles, samples it into keyframe offsets or
+ * a CSS `linear()` easing, and reports position and velocity at any time so an
+ * interrupted animation can be retargeted without a velocity jump.
+ *
+ * Hostile inputs are clamped: stiffness, damping, mass, velocity and sample
+ * counts have fixed ranges, NaN falls back to the defaults, and the settle
+ * search never evaluates more than `MAX_SPRING_MS + 1` points.
+ */
+/** Longest spring (and any Texuli motion) duration, in milliseconds. */
+export const MAX_SPRING_MS = 1000;
+/** Default sample count for keyframes and `linear()` easings. */
+export const DEFAULT_SPRING_SAMPLES = 40;
+/** Largest sample count accepted (keeps `linear()` strings short). */
+export const MAX_SPRING_SAMPLES = 120;
+/** Spring used when parameters are missing or not finite. */
+export const DEFAULT_SPRING = Object.freeze({
+    stiffness: 170,
+    damping: 26,
+    mass: 1,
+});
+function clamp(value, min, max, fallback) {
+    if (typeof value !== 'number' || Number.isNaN(value))
+        return fallback;
+    return Math.min(max, Math.max(min, value));
+}
+/** Clamp spring parameters into the supported ranges; NaN takes the default. */
+export function normalizeSpring(params) {
+    const p = params ?? {};
+    return {
+        stiffness: clamp(p.stiffness ?? DEFAULT_SPRING.stiffness, 1, 10000, DEFAULT_SPRING.stiffness),
+        damping: clamp(p.damping ?? DEFAULT_SPRING.damping, 0, 1000, DEFAULT_SPRING.damping),
+        mass: clamp(p.mass ?? DEFAULT_SPRING.mass, 0.01, 1000, DEFAULT_SPRING.mass),
+    };
+}
+/** Damping ratio ζ = c / (2√(k·m)); below 1 overshoots, 1 is critical. */
+export function dampingRatio(params) {
+    const { stiffness, damping, mass } = normalizeSpring(params);
+    return damping / (2 * Math.sqrt(stiffness * mass));
+}
+function solver(params, velocity) {
+    const { stiffness, damping, mass } = normalizeSpring(params);
+    const v0 = clamp(velocity, -1000, 1000, 0);
+    const w0 = Math.sqrt(stiffness / mass);
+    const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+    // Displacement y = position − 1, so y(0) = −1 and y'(0) = v0.
+    const a = -1;
+    if (Math.abs(zeta - 1) < 1e-6) {
+        const b = v0 + w0 * a;
+        return (t) => {
+            const e = Math.exp(-w0 * t);
+            return { position: 1 + (a + b * t) * e, velocity: e * (b - w0 * (a + b * t)) };
+        };
+    }
+    if (zeta < 1) {
+        const wd = w0 * Math.sqrt(1 - zeta * zeta);
+        const decay = zeta * w0;
+        const b = (v0 + decay * a) / wd;
+        return (t) => {
+            const e = Math.exp(-decay * t);
+            const cos = Math.cos(wd * t);
+            const sin = Math.sin(wd * t);
+            return {
+                position: 1 + e * (a * cos + b * sin),
+                velocity: e * ((-decay * a + wd * b) * cos + (-decay * b - wd * a) * sin),
+            };
+        };
+    }
+    const root = Math.sqrt(zeta * zeta - 1);
+    const r1 = -w0 * (zeta - root);
+    const r2 = -w0 * (zeta + root);
+    const c2 = (v0 - r1 * a) / (r2 - r1);
+    const c1 = a - c2;
+    return (t) => {
+        const e1 = Math.exp(r1 * t);
+        const e2 = Math.exp(r2 * t);
+        return { position: 1 + c1 * e1 + c2 * e2, velocity: r1 * c1 * e1 + r2 * c2 * e2 };
+    };
+}
+/** Position and velocity `ms` milliseconds after release (closed form, O(1)). */
+export function springState(params, ms, options = {}) {
+    const t = clamp(ms, 0, Number.MAX_SAFE_INTEGER, 0) / 1000;
+    return solver(params, options.velocity ?? 0)(t);
+}
+/**
+ * When the spring comes to rest: the first millisecond after which every
+ * sampled millisecond stays inside the rest thresholds. Bounded: at most
+ * `MAX_SPRING_MS + 1` closed-form evaluations.
+ */
+export function springSettle(params, options = {}) {
+    const solve = solver(params, options.velocity ?? 0);
+    const restDelta = clamp(options.restDelta ?? 0.001, 1e-6, 0.5, 0.001);
+    const restSpeed = clamp(options.restSpeed ?? 0.01, 1e-6, 100, 0.01);
+    let lastMoving = -1;
+    for (let ms = 0; ms <= MAX_SPRING_MS; ms++) {
+        const s = solve(ms / 1000);
+        if (Math.abs(1 - s.position) >= restDelta || Math.abs(s.velocity) >= restSpeed) {
+            lastMoving = ms;
+        }
+    }
+    if (lastMoving >= MAX_SPRING_MS)
+        return { durationMs: MAX_SPRING_MS, settled: false };
+    return { durationMs: lastMoving + 1, settled: true };
+}
+function sampleCount(samples) {
+    return Math.round(clamp(samples ?? DEFAULT_SPRING_SAMPLES, 2, MAX_SPRING_SAMPLES, DEFAULT_SPRING_SAMPLES));
+}
+/**
+ * Sample the spring at evenly spaced times across its settle duration. The
+ * first point is the start position (0) and the last is pinned to 1, so a
+ * spring cut at `MAX_SPRING_MS` lands exactly on its target.
+ */
+export function springSamples(params, options = {}) {
+    const settle = springSettle(params, options);
+    const count = sampleCount(options.samples);
+    const solve = solver(params, options.velocity ?? 0);
+    const points = [];
+    for (let i = 0; i < count; i++) {
+        const t = (settle.durationMs * i) / (count - 1) / 1000;
+        points.push(i === count - 1 ? 1 : round(solve(t).position));
+    }
+    points[0] = 0;
+    return { ...settle, points };
+}
+function round(value) {
+    const r = Math.round(value * 10000) / 10000;
+    return Object.is(r, -0) ? 0 : r;
+}
+/**
+ * A CSS `linear()` easing that traces the spring, with its duration. Points
+ * are evenly spaced, so no stop percentages are needed.
+ *
+ * @example
+ * const { easing, durationMs } = springEasing({ stiffness: 400, damping: 30, mass: 1 });
+ * element.animate(keyframes, { duration: durationMs, easing });
+ */
+export function springEasing(params, options = {}) {
+    const { points, durationMs, settled } = springSamples(params, options);
+    return { easing: `linear(${points.join(', ')})`, durationMs, settled };
+}
+/**
+ * Keyframes for any property: `build(progress)` maps a spring position to a
+ * keyframe (for example a transform). Offsets are evenly spaced.
+ */
+export function springKeyframes(params, build, options = {}) {
+    const { points, durationMs, settled } = springSamples(params, options);
+    const last = points.length - 1;
+    const keyframes = points.map((p, i) => ({ ...build(p), offset: i / last }));
+    return { keyframes, durationMs, settled };
+}
+/**
+ * Velocity for a retargeted spring: a velocity measured in the old segment's
+ * progress units, converted to the new segment (`newSpan` / `oldSpan` are the
+ * distances in any shared unit). Zero or non-finite spans give 0.
+ */
+export function retargetVelocity(velocity, oldSpan, newSpan) {
+    if (!Number.isFinite(velocity) || !Number.isFinite(oldSpan) || !Number.isFinite(newSpan))
+        return 0;
+    if (newSpan === 0)
+        return 0;
+    return clamp((velocity * oldSpan) / newSpan, -1000, 1000, 0);
+}

package/dist/overlay/core.js

@@ -161,10 +161,16 @@ export function createOverlayCore(options, features = {}) {
     /**
      * R16: an exempt region shown in the top layer (the toast region as a
      * `popover`) must keep painting above the overlay that just joined it.
-     * The top layer orders by show time, so re-show it.
+     * The top layer orders by show time, so re-show it. Exemptions registered
+     * with `raise: false` (a dialog backdrop, a menu or listbox opened inside a
+     * modal) stay where they are: re-showing them would cover this overlay.
      */
     function raiseExemptPopovers() {
-        for (const region of exemptElements()) {
+        const regions = (inertRegistry()?.exemptions() ?? [])
+            .filter((entry) => entry.raise !== false)
+            .map((entry) => entry.element)
+            .filter((region) => region !== element && !element.contains(region));
+        for (const region of regions) {
             const popover = region;
             try {
                 if (!popover.matches(':popover-open'))
@@ -239,7 +245,12 @@ export function createOverlayCore(options, features = {}) {
         else if (inert && inert.size() > 0 && isLive(element)) {
             // A menu or popover opened from inside a modal: keep it live while open,
             // even when it sits outside the modal (portaled to the body).
-            liveExemption = inert.exempt({ element, label: options.label ?? 'overlay' });
+            // `raise: false`: an overlay opened later from this one must stay above it.
+            liveExemption = inert.exempt({
+                element,
+                label: options.label ?? 'overlay',
+                raise: false,
+            });
         }
         if (wantsTrap && features.focusScope) {
             focusScope = features.focusScope(element, {

package/dist/zip/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/zip: a deterministic ZIP writer (stored, or deflated through
+ * the platform `CompressionStream`) and CRC-32 (ADR-016).
+ */
+export { assertZipPath, type CompressionFormatName, canCompress, compressBytes, crc32, writeZip, writeZipAsync, type ZipEntry, type ZipOptions, } from './zip.js';

package/dist/zip/index.js

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/zip: a deterministic ZIP writer (stored, or deflated through
+ * the platform `CompressionStream`) and CRC-32 (ADR-016).
+ */
+export { assertZipPath, canCompress, compressBytes, crc32, writeZip, writeZipAsync, } from "./zip.js";

package/dist/zip/zip.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A deterministic ZIP writer for export packages (ADR-016). Entries keep
+ * their order, use UTF-8 names and a fixed 1980-01-01 timestamp, so the
+ * same input always produces the same bytes. `writeZip` stores entries
+ * (synchronous, no compression); `writeZipAsync` deflates them through the
+ * platform `CompressionStream` when it exists and keeps an entry stored when
+ * deflate is missing or would not make it smaller. ZIP64 is not supported.
+ */
+export interface ZipEntry {
+    path: string;
+    data: Uint8Array | string;
+    /** `writeZipAsync` only: `false` keeps this entry stored (an already compressed image). */
+    compress?: boolean;
+}
+export interface ZipOptions {
+    /** Deflate entries when the platform can (default true). */
+    compress?: boolean;
+}
+export type CompressionFormatName = 'deflate' | 'deflate-raw';
+/** CRC-32 (IEEE 802.3), as ZIP and PNG use. */
+export declare function crc32(data: Uint8Array): number;
+/** Refuse empty, absolute, backslashed, dot-segment and control-character paths (no traversal on extract). */
+export declare function assertZipPath(path: string): void;
+/** A stored (uncompressed) ZIP, synchronously. */
+export declare function writeZip(entries: readonly ZipEntry[]): Uint8Array;
+/** True when the platform has `CompressionStream` with raw deflate. */
+export declare function canCompress(format?: CompressionFormatName): boolean;
+/**
+ * Compress bytes with the platform `CompressionStream` (`deflate` is the
+ * zlib wrapper PDF's FlateDecode reads; `deflate-raw` is what ZIP stores),
+ * or `null` when the platform has no such stream.
+ */
+export declare function compressBytes(data: Uint8Array, format: CompressionFormatName): Promise<Uint8Array | null>;
+/** A ZIP whose entries are deflated where the platform can and where it makes them smaller. */
+export declare function writeZipAsync(entries: readonly ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;

package/dist/zip/zip.js

@@ -0,0 +1,190 @@
+const MAX_ENTRIES = 0xffff;
+const MAX_SIZE = 0xffffffff;
+const DOS_TIME = 0;
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+const UTF8_FLAG = 0x0800;
+const STORED = 0;
+const DEFLATED = 8;
+let crcTable;
+function table() {
+    if (crcTable)
+        return crcTable;
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        crcTable[n] = c >>> 0;
+    }
+    return crcTable;
+}
+/** CRC-32 (IEEE 802.3), as ZIP and PNG use. */
+export function crc32(data) {
+    const lookup = table();
+    let crc = 0xffffffff;
+    for (let index = 0; index < data.length; index += 1) {
+        crc = lookup[(crc ^ data[index]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** Refuse empty, absolute, backslashed, dot-segment and control-character paths (no traversal on extract). */
+export function assertZipPath(path) {
+    if (typeof path !== 'string' ||
+        path.length === 0 ||
+        path.startsWith('/') ||
+        path.includes('\\') ||
+        path.split('/').some((segment) => segment === '' || segment === '.' || segment === '..') ||
+        [...path].some((character) => (character.codePointAt(0) ?? 0) < 0x20)) {
+        throw new TypeError(`Unsafe ZIP entry path: ${JSON.stringify(path)}`);
+    }
+}
+function prepare(entries) {
+    if (entries.length > MAX_ENTRIES)
+        throw new RangeError('Too many ZIP entries.');
+    const encoder = new TextEncoder();
+    const seen = new Set();
+    const raw = [];
+    const prepared = entries.map((entry) => {
+        assertZipPath(entry.path);
+        if (seen.has(entry.path))
+            throw new TypeError(`Duplicate ZIP entry: ${entry.path}`);
+        seen.add(entry.path);
+        const name = encoder.encode(entry.path);
+        const data = typeof entry.data === 'string' ? encoder.encode(entry.data) : entry.data;
+        if (data.length > MAX_SIZE)
+            throw new RangeError(`ZIP entry is too large: ${entry.path}`);
+        raw.push(data);
+        return { name, data, size: data.length, crc: crc32(data), method: STORED };
+    });
+    return { prepared, raw };
+}
+function assemble(prepared) {
+    const localSize = prepared.reduce((sum, entry) => sum + 30 + entry.name.length + entry.data.length, 0);
+    const centralSize = prepared.reduce((sum, entry) => sum + 46 + entry.name.length, 0);
+    if (localSize + centralSize > MAX_SIZE)
+        throw new RangeError('ZIP archive is too large.');
+    const bytes = new Uint8Array(localSize + centralSize + 22);
+    const view = new DataView(bytes.buffer);
+    let offset = 0;
+    const offsets = [];
+    for (const entry of prepared) {
+        offsets.push(offset);
+        view.setUint32(offset, 0x04034b50, true);
+        view.setUint16(offset + 4, 20, true);
+        view.setUint16(offset + 6, UTF8_FLAG, true);
+        view.setUint16(offset + 8, entry.method, true);
+        view.setUint16(offset + 10, DOS_TIME, true);
+        view.setUint16(offset + 12, DOS_DATE, true);
+        view.setUint32(offset + 14, entry.crc, true);
+        view.setUint32(offset + 18, entry.data.length, true);
+        view.setUint32(offset + 22, entry.size, true);
+        view.setUint16(offset + 26, entry.name.length, true);
+        view.setUint16(offset + 28, 0, true);
+        bytes.set(entry.name, offset + 30);
+        bytes.set(entry.data, offset + 30 + entry.name.length);
+        offset += 30 + entry.name.length + entry.data.length;
+    }
+    const centralStart = offset;
+    prepared.forEach((entry, index) => {
+        view.setUint32(offset, 0x02014b50, true);
+        view.setUint16(offset + 4, 20, true);
+        view.setUint16(offset + 6, 20, true);
+        view.setUint16(offset + 8, UTF8_FLAG, true);
+        view.setUint16(offset + 10, entry.method, true);
+        view.setUint16(offset + 12, DOS_TIME, true);
+        view.setUint16(offset + 14, DOS_DATE, true);
+        view.setUint32(offset + 16, entry.crc, true);
+        view.setUint32(offset + 20, entry.data.length, true);
+        view.setUint32(offset + 24, entry.size, true);
+        view.setUint16(offset + 28, entry.name.length, true);
+        view.setUint16(offset + 30, 0, true);
+        view.setUint16(offset + 32, 0, true);
+        view.setUint16(offset + 34, 0, true);
+        view.setUint16(offset + 36, 0, true);
+        view.setUint32(offset + 38, 0, true);
+        view.setUint32(offset + 42, offsets[index], true);
+        bytes.set(entry.name, offset + 46);
+        offset += 46 + entry.name.length;
+    });
+    view.setUint32(offset, 0x06054b50, true);
+    view.setUint16(offset + 4, 0, true);
+    view.setUint16(offset + 6, 0, true);
+    view.setUint16(offset + 8, prepared.length, true);
+    view.setUint16(offset + 10, prepared.length, true);
+    view.setUint32(offset + 12, offset - centralStart, true);
+    view.setUint32(offset + 16, centralStart, true);
+    view.setUint16(offset + 20, 0, true);
+    return bytes;
+}
+/** A stored (uncompressed) ZIP, synchronously. */
+export function writeZip(entries) {
+    return assemble(prepare(entries).prepared);
+}
+/** True when the platform has `CompressionStream` with raw deflate. */
+export function canCompress(format = 'deflate-raw') {
+    const Ctor = globalThis.CompressionStream;
+    if (typeof Ctor !== 'function')
+        return false;
+    try {
+        new Ctor(format);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Compress bytes with the platform `CompressionStream` (`deflate` is the
+ * zlib wrapper PDF's FlateDecode reads; `deflate-raw` is what ZIP stores),
+ * or `null` when the platform has no such stream.
+ */
+export async function compressBytes(data, format) {
+    const Ctor = globalThis.CompressionStream;
+    if (typeof Ctor !== 'function')
+        return null;
+    let stream;
+    try {
+        stream = new Ctor(format);
+    }
+    catch {
+        return null;
+    }
+    const writer = stream.writable.getWriter();
+    // Write and close without awaiting: the readable side drains the stream.
+    writer.write(data).catch(() => { });
+    writer.close().catch(() => { });
+    const reader = stream.readable.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        total += value.length;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+/** A ZIP whose entries are deflated where the platform can and where it makes them smaller. */
+export async function writeZipAsync(entries, options = {}) {
+    const { prepared, raw } = prepare(entries);
+    if (options.compress !== false && canCompress('deflate-raw')) {
+        for (let index = 0; index < prepared.length; index += 1) {
+            if (entries[index]?.compress === false)
+                continue;
+            const entry = prepared[index];
+            const packed = await compressBytes(raw[index], 'deflate-raw');
+            if (packed && packed.length < entry.data.length) {
+                entry.data = packed;
+                entry.method = DEFLATED;
+            }
+        }
+    }
+    return assemble(prepared);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@texuli/core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Texels: framework-free behavior and policy that every Texuli component is built from.",
   "keywords": [
     "svelte",
@@ -41,6 +41,9 @@
     "./keyboard": "./dist/keyboard/index.js",
     "./layer-stack": "./dist/layer-stack/index.js",
     "./lazy": "./dist/lazy/index.js",
+    "./markup": "./dist/markup/index.js",
+    "./motion": "./dist/motion/index.js",
+    "./motion/spring": "./dist/motion/spring.js",
     "./overlay": "./dist/overlay/index.js",
     "./overlay-core": "./dist/overlay/core-entry.js",
     "./portal": "./dist/portal/index.js",
@@ -50,7 +53,8 @@
     "./roving": "./dist/roving/index.js",
     "./scroll-lock": "./dist/scroll-lock/scroll-lock.js",
     "./tabbable": "./dist/tabbable/index.js",
-    "./url-policy": "./dist/url-policy/index.js"
+    "./url-policy": "./dist/url-policy/index.js",
+    "./zip": "./dist/zip/index.js"
   },
   "files": [
     "dist"