@octane-xplat/nativescript-mason-core 0.0.1 → 1.0.0-beta.1

package/css-colors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves CSS colour functions the native parsers don't read.
+ *
+ * String-valued properties (`box-shadow`, `background`, `border`, `filter`,
+ * `text-shadow`, ...) reach Android, iOS and Windows as the CSS text, and
+ * their parsers know hex, `rgb()`/`hsl()` and named colours only, so
+ * `0 2px 4px color-mix(in oklch, #000 4%, transparent)` would draw opaque
+ * black. Each colour function is replaced by its `rgba()` value first.
+ *
+ * Values that still hold a `var()` are left alone: there's nothing to resolve
+ * against yet.
+ */
+/**
+ * @param toRgba resolves one colour (`oklch(60% 0.2 240)`) to `rgba(...)`, or
+ * returns null when it can't.
+ */
+export declare function resolveCssColors(value: string, toRgba: (color: string) => string | null): string;

package/css-colors.js

@@ -0,0 +1,54 @@
+/**
+ * Resolves CSS colour functions the native parsers don't read.
+ *
+ * String-valued properties (`box-shadow`, `background`, `border`, `filter`,
+ * `text-shadow`, ...) reach Android, iOS and Windows as the CSS text, and
+ * their parsers know hex, `rgb()`/`hsl()` and named colours only, so
+ * `0 2px 4px color-mix(in oklch, #000 4%, transparent)` would draw opaque
+ * black. Each colour function is replaced by its `rgba()` value first.
+ *
+ * Values that still hold a `var()` are left alone: there's nothing to resolve
+ * against yet.
+ */
+const COLOR_FUNCTION = /(?<![\w-])(color-mix|oklch|oklab|lab|lch|hwb|color|rgba?|hsla?)\(/gi;
+// `rgb()`/`hsl()` only need resolving in their space-separated form.
+const LEGACY_FUNCTION = /^(rgba?|hsla?)$/i;
+const VAR = /var\(/i;
+/**
+ * @param toRgba resolves one colour (`oklch(60% 0.2 240)`) to `rgba(...)`, or
+ * returns null when it can't.
+ */
+export function resolveCssColors(value, toRgba) {
+    if (!value || !value.includes('(')) {
+        return value;
+    }
+    let out = '';
+    let last = 0;
+    COLOR_FUNCTION.lastIndex = 0;
+    let match;
+    while ((match = COLOR_FUNCTION.exec(value))) {
+        const open = match.index + match[0].length - 1;
+        const close = closingParen(value, open);
+        if (close === -1) {
+            break;
+        }
+        const call = value.slice(match.index, close + 1);
+        const skip = (LEGACY_FUNCTION.test(match[1]) && call.includes(',')) || VAR.test(call);
+        out += value.slice(last, match.index) + ((skip ? null : toRgba(call)) ?? call);
+        last = close + 1;
+        COLOR_FUNCTION.lastIndex = last;
+    }
+    return last === 0 ? value : out + value.slice(last);
+}
+function closingParen(value, open) {
+    let depth = 0;
+    for (let i = open; i < value.length; i++) {
+        if (value[i] === '(') {
+            depth++;
+        }
+        else if (value[i] === ')' && --depth === 0) {
+            return i;
+        }
+    }
+    return -1;
+}

package/css-environment.d.ts

@@ -0,0 +1,49 @@
+/** Native hosts supply logical (device-independent) pixels, scoped to one view subtree. */
+export interface CssSafeAreaInsets {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface CssEnvironmentHost {
+    readonly parent?: CssEnvironmentHost | null;
+    on?(event: string, callback: () => void): void;
+    off?(event: string, callback: () => void): void;
+}
+/** The host owns window selection, native observation and subscription teardown. */
+export interface CssEnvironmentSource {
+    read(): CssSafeAreaInsets | null;
+    subscribe(changed: () => void): () => void;
+}
+/** Core host lifecycle adapter: observe lazily, only when a subtree actually uses env(). */
+export declare function registerAutomaticCssEnvironment(host: CssEnvironmentHost, create: () => CssEnvironmentSource): () => void;
+declare const shorthand: unique symbol;
+interface EnvironmentShorthand {
+    value: number;
+    unit: 'dip';
+    css: string;
+    [shorthand]: {
+        split: (value: string) => unknown[];
+        index: number;
+    };
+}
+/** Keep parse-time box shorthands pending until the effective longhand has a host context. */
+export declare function cssEnvironmentShorthand(value: string, split: (value: string) => unknown[], count: number): unknown[] | undefined;
+/** Direct Style box setters need the same deferred split as stylesheet shorthands. */
+export declare function cssEnvironmentSides(value: string): unknown[] | undefined;
+export declare function isCssEnvironmentShorthand(value: unknown): value is EnvironmentShorthand;
+/** Publish a host's current safe area. Missing values are unavailable; zero is a real inset. */
+export declare function setCssEnvironment(host: CssEnvironmentHost, insets: CssSafeAreaInsets | null): void;
+/** Remove the host boundary and re-evaluate styles against their next ancestor context. */
+export declare function clearCssEnvironment(host: CssEnvironmentHost): void;
+/** Bind a host-owned native observer. Call the returned function when that host is disposed. */
+export declare function bindCssEnvironment(host: CssEnvironmentHost, source: CssEnvironmentSource): () => void;
+/** Substitute env() before the existing CSS math/unit parser; undefined means invalid/unavailable. */
+export declare function resolveCssEnvironment(value: string, insets?: CssSafeAreaInsets): string | undefined;
+/** Replay after reparenting/native recreation; publish changes through setCssEnvironment instead. */
+export declare function refreshCssEnvironment(host: CssEnvironmentHost): void;
+/** Core build adapter only: called at a leaf style setter, after cascade/var()/shorthand expansion. */
+export declare function environmentStyleValue(target: object, name: string, value: unknown): unknown;
+/** Stop replaying a released native style helper, including its lifecycle listeners. */
+export declare function releaseCssEnvironmentStyle(target: object): void;
+export {};

package/css-environment.js

@@ -0,0 +1,309 @@
+import { splitMargin } from './css-shorthands';
+import { reportCssDiagnostic } from './diagnostics';
+const environments = new WeakMap();
+const bindings = new WeakMap();
+const automaticSources = new WeakMap();
+/** Core host lifecycle adapter: observe lazily, only when a subtree actually uses env(). */
+export function registerAutomaticCssEnvironment(host, create) {
+    const entry = { create, starting: false };
+    automaticSources.set(host, entry);
+    refreshCssEnvironment(host);
+    return () => {
+        if (automaticSources.get(host) !== entry)
+            return;
+        automaticSources.delete(host);
+        entry.stop?.();
+    };
+}
+function ensureAutomaticEnvironment(owner) {
+    for (let host = owner; host; host = host.parent ?? undefined) {
+        const entry = automaticSources.get(host);
+        if (entry) {
+            if (!entry.stop && !entry.starting && !bindings.has(host) && !environments.has(host)) {
+                entry.starting = true;
+                try {
+                    entry.stop = bindCssEnvironment(host, entry.create());
+                }
+                finally {
+                    entry.starting = false;
+                }
+            }
+            return;
+        }
+        if (environments.has(host))
+            return;
+    }
+}
+const sides = ['top', 'right', 'bottom', 'left'];
+const ENV = /\benv\(/i;
+const shorthand = Symbol('mason:environment-shorthand');
+/** Keep parse-time box shorthands pending until the effective longhand has a host context. */
+export function cssEnvironmentShorthand(value, split, count) {
+    if (!ENV.test(value))
+        return undefined;
+    return Array.from({ length: count }, (_, index) => ({
+        value: 0, unit: 'dip', css: value, [shorthand]: { split, index },
+    }));
+}
+/** Direct Style box setters need the same deferred split as stylesheet shorthands. */
+export function cssEnvironmentSides(value) {
+    return cssEnvironmentShorthand(value, splitMargin, 4);
+}
+export function isCssEnvironmentShorthand(value) {
+    return !!value && typeof value === 'object' && shorthand in value;
+}
+function snapshot(insets) {
+    const result = {};
+    for (const side of sides) {
+        const value = insets?.[side];
+        if (value !== undefined) {
+            if (!Number.isFinite(value) || value < 0)
+                throw new RangeError(`Invalid safe-area ${side} inset.`);
+            result[side] = value;
+        }
+    }
+    return result;
+}
+/** Publish a host's current safe area. Missing values are unavailable; zero is a real inset. */
+export function setCssEnvironment(host, insets) {
+    const next = snapshot(insets);
+    const previous = environments.get(host);
+    if (previous && sides.every((side) => previous[side] === next[side]))
+        return;
+    // An empty environment still establishes a window boundary: don't inherit another window's insets.
+    environments.set(host, next);
+    refreshCssEnvironment(host);
+}
+/** Remove the host boundary and re-evaluate styles against their next ancestor context. */
+export function clearCssEnvironment(host) {
+    if (environments.delete(host))
+        refreshCssEnvironment(host);
+}
+/** Bind a host-owned native observer. Call the returned function when that host is disposed. */
+export function bindCssEnvironment(host, source) {
+    if (bindings.has(host))
+        throw new Error('This host already has a CSS environment binding.');
+    const token = {};
+    bindings.set(host, token);
+    const update = () => {
+        if (bindings.get(host) === token)
+            setCssEnvironment(host, source.read());
+    };
+    let unsubscribe;
+    try {
+        update();
+        unsubscribe = source.subscribe(update);
+        update(); // Catch a change between the first read and subscription.
+    }
+    catch (error) {
+        bindings.delete(host);
+        try {
+            unsubscribe?.();
+        }
+        finally {
+            clearCssEnvironment(host);
+        }
+        throw error;
+    }
+    return () => {
+        if (bindings.get(host) !== token)
+            return;
+        bindings.delete(host);
+        try {
+            unsubscribe?.();
+        }
+        finally {
+            clearCssEnvironment(host);
+        }
+    };
+}
+function context(view) {
+    for (let current = view; current; current = current.parent ?? undefined) {
+        const value = environments.get(current);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+// Scan balanced CSS functions, preserving strings, comments and URL payloads.
+function close(value, start) {
+    let depth = 1;
+    for (let i = start; i < value.length; i++) {
+        if (value[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (value[i] === '"' || value[i] === "'") {
+            const quote = value[i++];
+            while (i < value.length && value[i] !== quote) {
+                if (value[i] === '\\')
+                    i++;
+                i++;
+            }
+        }
+        else if (value[i] === '/' && value[i + 1] === '*') {
+            const end = value.indexOf('*/', i + 2);
+            if (end < 0)
+                return -1;
+            i = end + 1;
+        }
+        else if (value[i] === '(')
+            depth++;
+        else if (value[i] === ')' && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/** Substitute env() before the existing CSS math/unit parser; undefined means invalid/unavailable. */
+export function resolveCssEnvironment(value, insets = {}) {
+    let result = '';
+    for (let i = 0; i < value.length;) {
+        if (value[i] === '\\') {
+            result += value.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        if (value[i] === '"' || value[i] === "'") {
+            const start = i;
+            const quote = value[i++];
+            while (i < value.length && value[i] !== quote) {
+                if (value[i] === '\\')
+                    i++;
+                i++;
+            }
+            result += value.slice(start, ++i);
+            continue;
+        }
+        if (value[i] === '/' && value[i + 1] === '*') {
+            const end = value.indexOf('*/', i + 2);
+            if (end < 0)
+                return undefined;
+            result += value.slice(i, end + 2);
+            i = end + 2;
+            continue;
+        }
+        const fn = /^([a-z_-][\w-]*)\(/i.exec(value.slice(i));
+        if (!fn) {
+            result += value[i++];
+            continue;
+        }
+        const start = i + fn[0].length;
+        const end = close(value, start);
+        if (end < 0)
+            return undefined;
+        const name = fn[1].toLowerCase();
+        const body = value.slice(start, end);
+        let replacement;
+        if (name === 'url')
+            replacement = value.slice(i, end + 1);
+        else if (name === 'env') {
+            // The first comma separates the environment name from an arbitrary fallback token sequence.
+            const comma = body.indexOf(',');
+            const identifier = (comma < 0 ? body : body.slice(0, comma)).replace(/\/\*[\s\S]*?\*\//g, ' ').trim();
+            const args = /^(-?[_a-zA-Z][_a-zA-Z0-9-]*)(?:\s+\+?\d+)*$/.exec(identifier);
+            if (!args)
+                return undefined;
+            const side = /^safe-area-inset-(top|right|bottom|left)$/.exec(identifier)?.[1];
+            const inset = side && insets[side];
+            if (typeof inset === 'number' && Number.isFinite(inset) && inset >= 0)
+                replacement = `${inset}px`;
+            else if (comma >= 0)
+                replacement = resolveCssEnvironment(body.slice(comma + 1).trim(), insets);
+        }
+        else {
+            const inner = resolveCssEnvironment(body, insets);
+            if (inner !== undefined)
+                replacement = `${fn[1]}(${inner})`;
+        }
+        if (replacement === undefined)
+            return undefined;
+        result += replacement;
+        i = end + 1;
+    }
+    return result;
+}
+const writesByTarget = new WeakMap();
+const targets = new Set();
+function replay(writes) {
+    const target = writes.target.deref();
+    if (target && writes.active) {
+        for (const [name, value] of Array.from(writes.values))
+            target[name] = value;
+    }
+}
+/** Replay after reparenting/native recreation; publish changes through setCssEnvironment instead. */
+export function refreshCssEnvironment(host) {
+    for (const ref of targets) {
+        const writes = ref.deref();
+        if (!writes?.target.deref()) {
+            if (writes)
+                stopWrites(writes);
+            targets.delete(ref);
+            continue;
+        }
+        for (let view = writes.owner?.deref(); view; view = view.parent ?? undefined) {
+            if (view === host) {
+                replay(writes);
+                break;
+            }
+        }
+    }
+}
+/** Core build adapter only: called at a leaf style setter, after cascade/var()/shorthand expansion. */
+export function environmentStyleValue(target, name, value) {
+    const style = target;
+    const owner = style.viewRef?.get?.() ?? style.viewRef?.deref?.() ?? style.view;
+    const text = typeof value === 'string' ? value : value?.css;
+    let writes = writesByTarget.get(target);
+    if (typeof text !== 'string' || !ENV.test(text)) {
+        writes?.values.delete(name);
+        if (writes && !writes.values.size)
+            releaseCssEnvironmentStyle(target);
+        return value;
+    }
+    ensureAutomaticEnvironment(owner);
+    if (!writes) {
+        writes = {
+            target: new WeakRef(target), owner: owner && new WeakRef(owner), values: new Map(), active: true,
+            loaded() { writes.active = true; replay(writes); },
+            unloaded() { writes.active = false; },
+        };
+        writesByTarget.set(target, writes);
+        targets.add(new WeakRef(writes));
+        owner?.on?.('loaded', writes.loaded);
+        owner?.on?.('unloaded', writes.unloaded);
+    }
+    writes.values.set(name, value);
+    let resolved = resolveCssEnvironment(text, context(owner));
+    if (resolved !== undefined && isCssEnvironmentShorthand(value)) {
+        try {
+            const pending = value[shorthand];
+            const part = pending.split(resolved)[pending.index];
+            resolved = typeof part === 'string' ? part : undefined;
+        }
+        catch {
+            resolved = undefined;
+        }
+    }
+    if (resolved === undefined) {
+        reportCssDiagnostic({ kind: 'not-implemented', name, value: text,
+            detail: 'env() is unavailable or invalid and has no usable fallback; the host must publish its window safe area' });
+        return text;
+    }
+    return resolved;
+}
+/** Stop replaying a released native style helper, including its lifecycle listeners. */
+export function releaseCssEnvironmentStyle(target) {
+    const writes = writesByTarget.get(target);
+    if (!writes)
+        return;
+    stopWrites(writes);
+    writesByTarget.delete(target);
+}
+function stopWrites(writes) {
+    const owner = writes.owner?.deref();
+    owner?.off?.('loaded', writes.loaded);
+    owner?.off?.('unloaded', writes.unloaded);
+    writes.values.clear();
+    writes.active = false;
+}

package/css-filter.d.ts

@@ -0,0 +1,17 @@
+export type ColorMatrix = number[];
+export type FilterStep = {
+    kind: 'matrix';
+    matrix: ColorMatrix;
+} | {
+    kind: 'blur';
+    sigma: number;
+} | {
+    kind: 'shadow';
+    x: number;
+    y: number;
+    sigma: number;
+    color: string | null;
+};
+export declare function composeMatrices(first: ColorMatrix, second: ColorMatrix): ColorMatrix;
+export declare function parseCssFilter(value: string, toDip: (token: string) => number | undefined): FilterStep[];
+export declare function encodeCssFilter(steps: FilterStep[], argbOf: (color: string | null) => number): string;

package/css-filter.js

@@ -0,0 +1,140 @@
+import { parseBoxShadows } from './box-shadow';
+import { parseAngle } from './css-transform';
+const IDENTITY = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
+function amount(arg, fallback) {
+    const t = arg.trim();
+    if (!t)
+        return fallback;
+    const n = parseFloat(t);
+    if (!Number.isFinite(n))
+        return fallback;
+    return t.endsWith('%') ? n / 100 : n;
+}
+const clamp01 = (n) => Math.min(1, Math.max(0, n));
+function rgb(rows) {
+    return [...rows[0], 0, 0, ...rows[1], 0, 0, ...rows[2], 0, 0, 0, 0, 0, 1, 0];
+}
+function grayscale(a) {
+    const k = 1 - clamp01(a);
+    return rgb([
+        [0.2126 + 0.7874 * k, 0.7152 - 0.7152 * k, 0.0722 - 0.0722 * k],
+        [0.2126 - 0.2126 * k, 0.7152 + 0.2848 * k, 0.0722 - 0.0722 * k],
+        [0.2126 - 0.2126 * k, 0.7152 - 0.7152 * k, 0.0722 + 0.9278 * k],
+    ]);
+}
+function sepia(a) {
+    const k = 1 - clamp01(a);
+    return rgb([
+        [0.393 + 0.607 * k, 0.769 - 0.769 * k, 0.189 - 0.189 * k],
+        [0.349 - 0.349 * k, 0.686 + 0.314 * k, 0.168 - 0.168 * k],
+        [0.272 - 0.272 * k, 0.534 - 0.534 * k, 0.131 + 0.869 * k],
+    ]);
+}
+function saturate(s) {
+    return rgb([
+        [0.213 + 0.787 * s, 0.715 - 0.715 * s, 0.072 - 0.072 * s],
+        [0.213 - 0.213 * s, 0.715 + 0.285 * s, 0.072 - 0.072 * s],
+        [0.213 - 0.213 * s, 0.715 - 0.715 * s, 0.072 + 0.928 * s],
+    ]);
+}
+function hueRotate(radians) {
+    const c = Math.cos(radians);
+    const s = Math.sin(radians);
+    return rgb([
+        [0.213 + c * 0.787 - s * 0.213, 0.715 - c * 0.715 - s * 0.715, 0.072 - c * 0.072 + s * 0.928],
+        [0.213 - c * 0.213 + s * 0.143, 0.715 + c * 0.285 + s * 0.14, 0.072 - c * 0.072 - s * 0.283],
+        [0.213 - c * 0.213 - s * 0.787, 0.715 - c * 0.715 + s * 0.715, 0.072 + c * 0.928 + s * 0.072],
+    ]);
+}
+function linear(slope, intercept) {
+    return [slope, 0, 0, 0, intercept, 0, slope, 0, 0, intercept, 0, 0, slope, 0, intercept, 0, 0, 0, 1, 0];
+}
+function alpha(a) {
+    return [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, clamp01(a), 0];
+}
+export function composeMatrices(first, second) {
+    const out = new Array(20).fill(0);
+    for (let row = 0; row < 4; row++) {
+        for (let col = 0; col < 5; col++) {
+            let v = col === 4 ? second[row * 5 + 4] : 0;
+            for (let k = 0; k < 4; k++)
+                v += second[row * 5 + k] * first[k * 5 + col];
+            out[row * 5 + col] = v;
+        }
+    }
+    return out;
+}
+const FUNCTION = /([a-z-]+)\s*\(((?:[^()]|\([^()]*\))*)\)/gi;
+export function parseCssFilter(value, toDip) {
+    const steps = [];
+    const v = (value ?? '').trim();
+    if (!v || v === 'none')
+        return steps;
+    const push = (matrix) => {
+        const last = steps[steps.length - 1];
+        if (last && last.kind === 'matrix')
+            last.matrix = composeMatrices(last.matrix, matrix);
+        else
+            steps.push({ kind: 'matrix', matrix });
+    };
+    for (const match of v.matchAll(FUNCTION)) {
+        const name = match[1].toLowerCase();
+        const arg = match[2];
+        switch (name) {
+            case 'blur': {
+                const t = arg.trim();
+                const sigma = t ? (toDip(t) ?? parseFloat(t)) : 0;
+                if (Number.isFinite(sigma) && sigma > 0)
+                    steps.push({ kind: 'blur', sigma });
+                break;
+            }
+            case 'grayscale':
+                push(grayscale(amount(arg, 1)));
+                break;
+            case 'sepia':
+                push(sepia(amount(arg, 1)));
+                break;
+            case 'saturate':
+                push(saturate(Math.max(0, amount(arg, 1))));
+                break;
+            case 'hue-rotate':
+                push(hueRotate(arg.trim() ? parseAngle(arg) : 0));
+                break;
+            case 'invert': {
+                const a = clamp01(amount(arg, 1));
+                push(linear(1 - 2 * a, a));
+                break;
+            }
+            case 'opacity':
+                push(alpha(amount(arg, 1)));
+                break;
+            case 'brightness':
+                push(linear(Math.max(0, amount(arg, 1)), 0));
+                break;
+            case 'contrast': {
+                const c = Math.max(0, amount(arg, 1));
+                push(linear(c, 0.5 - 0.5 * c));
+                break;
+            }
+            case 'drop-shadow': {
+                const shadow = parseBoxShadows(arg, toDip)[0];
+                if (shadow)
+                    steps.push({ kind: 'shadow', x: shadow.offsetX, y: shadow.offsetY, sigma: shadow.blur / 2, color: shadow.color });
+                break;
+            }
+        }
+    }
+    return steps.filter((s) => s.kind !== 'matrix' || s.matrix.some((n, i) => Math.abs(n - IDENTITY[i]) > 1e-6));
+}
+export function encodeCssFilter(steps, argbOf) {
+    const round = (n) => Math.round(n * 1e6) / 1e6;
+    return steps
+        .map((s) => {
+        if (s.kind === 'matrix')
+            return 'm,' + s.matrix.map(round).join(',');
+        if (s.kind === 'blur')
+            return `b,${round(s.sigma)}`;
+        return `d,${round(s.x)},${round(s.y)},${round(s.sigma)},${argbOf(s.color) >>> 0}`;
+    })
+        .join(';');
+}

package/css-keyframes.d.ts

@@ -0,0 +1,41 @@
+import type { CssAnimationProperty, Style, View } from '@nativescript/core';
+/**
+ * CSS keyframes for properties MasonKit draws itself.
+ *
+ * Core plays each keyframe interval with its native Animation, which only knows opacity,
+ * background-color, transforms, width and height. MasonKit's animatable properties are taken
+ * out of core's keyframes and interpolated every frame on the same timeline instead: delay,
+ * duration, iterations, each interval's timing function and `animation-fill-mode`.
+ */
+type Interpolate = (from: string, to: string, t: number) => string;
+interface Track {
+    property: CssAnimationProperty<Style, string>;
+    interpolate: Interpolate;
+    /** [time in ms from the start of an iteration, value]; time-ordered. */
+    stops: [number, string][];
+}
+/** Lets keyframes animate [property] with [interpolate]; [initial] is its CSS initial value. */
+export declare function registerKeyframeProperty(property: CssAnimationProperty<Style, string>, interpolate: Interpolate, initial: string): void;
+/** Interpolates `<position>` lists (`mask-position`, `background-position`). */
+export declare const interpolatePositionList: Interpolate;
+/** Interpolates `<bg-size>` lists (`mask-size`, `background-size`). */
+export declare const interpolateSizeList: Interpolate;
+/** Core's keyframe curve as an easing function; `linear`, `spring` and unknown curves are linear. */
+export declare function easing(curve: any): (t: number) => number;
+/**
+ * The value of [track] at [time] ms into an iteration of [total] ms. [curveAt] gives the timing
+ * function of the interval starting at a time. A missing first or last keyframe uses [base], the
+ * element's own value, as CSS does.
+ */
+export declare function sampleTrack(track: Pick<Track, 'interpolate' | 'stops'>, base: string, total: number, time: number, curveAt: (start: number) => (t: number) => number): string;
+/**
+ * Windows: View.animate()'s scale, rotate and translate, played per frame on the View properties
+ * (core's storyboards target a transform that doesn't show on a Mason view).
+ */
+export declare function animateTransforms(view: View, options: any): {
+    done: Promise<void>;
+    cancel: () => void;
+};
+/** Installs the keyframe hooks once. */
+export declare function installKeyframes(): void;
+export {};