@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/value-types/measure-resolve.cjs

@@ -0,0 +1,325 @@
+"use strict";
+// REQ-VALUETYPE-013/014 — positional length measure-resolve (R13 value-breadth).
+// Pure recognition + arithmetic against a host-supplied layout context. No DOM, no RN.
+// Pin: motion-dom DOMKeyframesResolver measure path; catalog Animation-between-value-types,
+// height-auto*, Shared-layout-continuity* calc(100vw - 100px).
+//
+// Law: calc is first-class — never silent complex tokenization of interior numbers.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumeric = exports.MeasureResolveContextError = exports.POSITIONAL_LENGTH_AXES = void 0;
+exports.isPositionalLengthAxis = isPositionalLengthAxis;
+exports.executableLengthValueRefusal = executableLengthValueRefusal;
+exports.isAuto = isAuto;
+exports.isCalc = isCalc;
+exports.parseLengthTargetVerdict = parseLengthTargetVerdict;
+exports.parseLengthTarget = parseLengthTarget;
+exports.isLengthTarget = isLengthTarget;
+exports.resolveLengthToPx = resolveLengthToPx;
+exports.needsLengthMeasureResolve = needsLengthMeasureResolve;
+const numeric_1 = require("./numeric.cjs");
+Object.defineProperty(exports, "parseNumeric", { enumerable: true, get: function () { return numeric_1.parseNumeric; } });
+const POSITIONAL_LENGTH_AXIS_SET = new Set([
+    'width',
+    'height',
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'x',
+    'y',
+]);
+/** The positional keys whose length STRINGS any engine may measure-resolve (REQ-VALUETYPE-013). */
+exports.POSITIONAL_LENGTH_AXES = Object.freeze([
+    'width',
+    'height',
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'x',
+    'y',
+]);
+/** Runtime membership of the positional length axis set (cross-engine, one authority). */
+function isPositionalLengthAxis(key) {
+    return POSITIONAL_LENGTH_AXIS_SET.has(key);
+}
+/**
+ * The ONE key-aware executable value matrix (review fe5d455ffde7 / 91d41675d511): a
+ * measure-resolved length string (scalar, or any keyframe element — a null FIRST element is the
+ * legal from-current marker) executes only on the positional keys, and `auto` only for
+ * width/height (the intrinsic content measure; the positional-auto remainder stays loud).
+ * Returns the named refusal, or null when the value rides another lane (number, non-string) or
+ * is executable. Used by every supplying boundary: core target validation (web + native), the
+ * variants dictionary gate, the gesture-state gate, and the style-base gate.
+ */
+function executableLengthValueRefusal(key, value) {
+    if (typeof value === 'number')
+        return null;
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index++) {
+            const element = value[index];
+            if (element === null && index === 0)
+                continue;
+            const refusal = executableLengthValueRefusal(key, element);
+            if (refusal !== null)
+                return refusal;
+        }
+        return null;
+    }
+    if (typeof value !== 'string')
+        return null;
+    if (!isLengthTarget(value))
+        return null; // not a length string — the value-type lane owns it
+    if (!isPositionalLengthAxis(key)) {
+        return (`measure-resolved length strings (%/auto/simple calc/px) execute only on the positional ` +
+            `keys (${exports.POSITIONAL_LENGTH_AXES.join(', ')}); '${key}' drives explicit numbers ` +
+            `(REQ-VALUETYPE-013)`);
+    }
+    if (isAuto(value) && key !== 'width' && key !== 'height') {
+        return (`not yet supported — positional 'auto' on '${key}' cannot measure-resolve ` +
+            '(REQ-VALUETYPE-013; auto resolves for width/height only, the intrinsic content measure)');
+    }
+    return null;
+}
+const CALC_OUTER_RE = /^calc\(\s*(.+)\s*\)$/i;
+// Pin-exercised simple binary forms only: term (op) term, each term a number/unit or nested not allowed.
+const SIMPLE_CALC_BODY_RE = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(?:px|%|vw|vh)?)\s*([+-])\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(?:px|%|vw|vh)?)$/i;
+function isAuto(raw) {
+    return raw.trim().toLowerCase() === 'auto';
+}
+/**
+ * Calc prefix detection (REQ-VALUETYPE-013): match `calc(` regardless of trailing `)`.
+ * Malformed/unclosed calc must NOT fall through to complex partial tokenization — parse
+ * routes it to a named refusal.
+ */
+function isCalc(raw) {
+    return /^calc\s*\(/i.test(raw.trim());
+}
+class MeasureResolveContextError extends Error {
+    reason;
+    axis;
+    constructor(message, reason, axis) {
+        super(message);
+        this.name = 'MeasureResolveContextError';
+        this.reason = reason;
+        this.axis = axis;
+    }
+}
+exports.MeasureResolveContextError = MeasureResolveContextError;
+/** Layout/inset axes: % of parent. Transform x/y: % of the element box (pin unit-conversion). */
+function percentReferenceSize(axis, ctx) {
+    if (axis === 'x')
+        return { size: ctx.autoWidth, label: 'element width (transform %)' };
+    if (axis === 'y')
+        return { size: ctx.autoHeight, label: 'element height (transform %)' };
+    if (axis === 'width' || axis === 'left' || axis === 'right') {
+        return { size: ctx.parentWidth, label: 'parent width' };
+    }
+    return { size: ctx.parentHeight, label: 'parent height' };
+}
+// The supported auto matrix is DIMENSIONS only (review e2b1b9c7013b): width/height auto is the
+// intrinsic content measure (the shipped height-auto capability). Positional auto
+// (left/right/top/bottom/x/y) is NOT Motion-faithful as an element-box size — motion-dom reads
+// computed left/top, bounding-box right/bottom, and the current transform translation — so it
+// stays loud with the named "not yet supported" format, never a silently unrelated endpoint.
+// The reason is typed ('unsupported-axis-auto'): it must never read as a deferrable
+// missing-element-measure (hosts would park the key behind onLayout instead of refusing it).
+function autoRefusal(axis) {
+    if (axis === 'width' || axis === 'height')
+        return null;
+    return new MeasureResolveContextError(`not yet supported — positional 'auto' on '${axis}' cannot measure-resolve ` +
+        '(REQ-VALUETYPE-013; auto resolves for width/height only, the intrinsic content measure; ' +
+        'positional left/right/top/bottom/x/y auto is the unsupported remainder)', 'unsupported-axis-auto', axis);
+}
+function autoSize(axis, ctx) {
+    return axis === 'width' ? ctx.autoWidth : ctx.autoHeight;
+}
+// Inputs and context components are validated finite, but the ARITHMETIC can still overflow
+// (review 46e1c8fd339a): calc(1e308px + 1e308px), 1e308% of a large parent, or a cancellation
+// to NaN (Infinity − Infinity) would otherwise reach driver invariants as a raw Infinity/NaN.
+// The resolved result is boundary-checked through the same typed channel — never deferred.
+function assertFiniteResolved(value, axis) {
+    if (!Number.isFinite(value)) {
+        throw new MeasureResolveContextError(`measure-resolve on '${axis}' produced a non-finite result (${value}); finite inputs ` +
+            'overflowed the driver lane, which requires finite px (REQ-VALUETYPE-013)', 'non-finite-result', axis);
+    }
+    return value;
+}
+function parseLengthTargetVerdict(raw) {
+    if (typeof raw === 'number') {
+        if (!Number.isFinite(raw)) {
+            return { parsed: null, refusal: `Cannot parse non-finite length target: ${raw}` };
+        }
+        return { parsed: { kind: 'px', value: raw }, refusal: null };
+    }
+    const s = raw.trim();
+    if (s.length === 0)
+        return { parsed: null, refusal: `Cannot parse empty length target` };
+    if (isAuto(s))
+        return { parsed: { kind: 'auto' }, refusal: null };
+    if (isCalc(s))
+        return parseSimpleCalcVerdict(s);
+    const verdict = (0, numeric_1.parseNumericVerdict)(s);
+    if (verdict.refusal !== null) {
+        return { parsed: null, refusal: verdict.refusal };
+    }
+    const { value, unit } = verdict.parsed;
+    if (unit === '' || unit === 'px')
+        return { parsed: { kind: 'px', value }, refusal: null };
+    if (unit === '%')
+        return { parsed: { kind: 'percent', value }, refusal: null };
+    if (unit === 'vw')
+        return { parsed: { kind: 'vw', value }, refusal: null };
+    if (unit === 'vh')
+        return { parsed: { kind: 'vh', value }, refusal: null };
+    return {
+        parsed: null,
+        refusal: `not yet supported — length unit "${unit}" in ${JSON.stringify(raw)} cannot measure-resolve ` +
+            `(REQ-VALUETYPE-013; supported: number/px/%/vw/vh/auto/simple calc)`,
+    };
+}
+/** Parse a single length term used inside simple calc or as a standalone target. */
+function parseLengthTarget(raw) {
+    const verdict = parseLengthTargetVerdict(raw);
+    if (verdict.refusal !== null)
+        throw new Error(verdict.refusal);
+    return verdict.parsed;
+}
+/**
+ * Total predicate: whether `raw` is a measure-resolved length form (no throw).
+ * Drivers use this at recognition boundaries — never bare try/catch over parseLengthTarget
+ * (unexpected faults must not be classified as “not a length”).
+ */
+function isLengthTarget(raw) {
+    return parseLengthTargetVerdict(raw).refusal === null;
+}
+/** Verdict-shaped simple calc — no catch: unexpected faults from RegExp/String propagate. */
+function parseSimpleCalcVerdict(raw) {
+    const s = raw.trim();
+    const outer = CALC_OUTER_RE.exec(s);
+    if (outer === null) {
+        return {
+            parsed: null,
+            refusal: `not yet supported — malformed calc ${JSON.stringify(raw)} (REQ-VALUETYPE-013)`,
+        };
+    }
+    const body = outer[1].trim();
+    // Nested parens / var() / multi-ops → loud incomplete (never partial complex).
+    if (body.includes('(') || /var\s*\(/i.test(body) || body.includes('*') || body.includes('/')) {
+        return {
+            parsed: null,
+            refusal: `not yet supported — calc form ${JSON.stringify(raw)} is outside the pin simple binary set ` +
+                `(REQ-VALUETYPE-013(d))`,
+        };
+    }
+    const m = SIMPLE_CALC_BODY_RE.exec(body);
+    if (m === null) {
+        return {
+            parsed: null,
+            refusal: `not yet supported — calc form ${JSON.stringify(raw)} is outside the pin simple binary set ` +
+                `(REQ-VALUETYPE-013(d))`,
+        };
+    }
+    const leftVerdict = parseLengthTargetVerdict(m[1]);
+    if (leftVerdict.refusal !== null)
+        return leftVerdict;
+    const rightVerdict = parseLengthTargetVerdict(m[3]);
+    if (rightVerdict.refusal !== null)
+        return rightVerdict;
+    const left = leftVerdict.parsed;
+    const right = rightVerdict.parsed;
+    const op = m[2];
+    if (left.kind === 'calc' ||
+        right.kind === 'calc' ||
+        left.kind === 'auto' ||
+        right.kind === 'auto') {
+        return {
+            parsed: null,
+            refusal: `not yet supported — nested/auto inside calc ${JSON.stringify(raw)} (REQ-VALUETYPE-013(d))`,
+        };
+    }
+    return { parsed: { kind: 'calc', raw: s, left, op, right }, refusal: null };
+}
+function resolveParsed(parsed, axis, ctx) {
+    switch (parsed.kind) {
+        case 'px':
+            return parsed.value;
+        case 'percent': {
+            const { size, label } = percentReferenceSize(axis, ctx);
+            if (size === undefined || !Number.isFinite(size)) {
+                const reason = axis === 'x' || axis === 'y' ? 'missing-element-measure' : 'missing-parent';
+                throw new MeasureResolveContextError(`Cannot measure-resolve percent length on ${axis}: ${label} missing from layout context ` +
+                    `(REQ-VALUETYPE-013)`, reason, axis);
+            }
+            return assertFiniteResolved((parsed.value / 100) * size, axis);
+        }
+        case 'vw': {
+            if (ctx.viewportWidth === undefined || !Number.isFinite(ctx.viewportWidth)) {
+                throw new MeasureResolveContextError(`Cannot measure-resolve vw length: viewportWidth missing from layout context (REQ-VALUETYPE-013)`, 'missing-viewport', axis);
+            }
+            return assertFiniteResolved((parsed.value / 100) * ctx.viewportWidth, axis);
+        }
+        case 'vh': {
+            if (ctx.viewportHeight === undefined || !Number.isFinite(ctx.viewportHeight)) {
+                throw new MeasureResolveContextError(`Cannot measure-resolve vh length: viewportHeight missing from layout context (REQ-VALUETYPE-013)`, 'missing-viewport', axis);
+            }
+            return assertFiniteResolved((parsed.value / 100) * ctx.viewportHeight, axis);
+        }
+        case 'auto': {
+            const refusal = autoRefusal(axis);
+            if (refusal !== null)
+                throw refusal;
+            const size = autoSize(axis, ctx);
+            if (size === undefined || !Number.isFinite(size)) {
+                throw new MeasureResolveContextError(`Cannot measure-resolve auto on ${axis}: auto measure missing from layout context (REQ-VALUETYPE-013)`, 'missing-element-measure', axis);
+            }
+            return size;
+        }
+        case 'calc': {
+            const l = resolveParsed(parsed.left, axis, ctx);
+            const r = resolveParsed(parsed.right, axis, ctx);
+            return assertFiniteResolved(parsed.op === '+' ? l + r : l - r, axis);
+        }
+    }
+}
+/**
+ * Resolve a length target to px using host layout context (Motion measure-then-mix law).
+ * Pure: all geometry arrives in `ctx`.
+ */
+function resolveLengthToPx(raw, axis, ctx) {
+    return resolveParsed(parseLengthTarget(raw), axis, ctx);
+}
+function familyOf(parsed) {
+    if (parsed.kind === 'px')
+        return 'px';
+    if (parsed.kind === 'calc')
+        return 'calc';
+    return parsed.kind;
+}
+/**
+ * Motion needsMeasurement — the pin's family decision (review ae0a42832d85): the SAME relative
+ * unit family returns WITHOUT a measure (%→%, vw→vw, vh→vh interpolate on the unit lane — on
+ * native, measured-endpoint animation per the recorded divergence, never a unit-string
+ * generator). auto and calc always measure; mixed families measure.
+ */
+function needsLengthMeasureResolve(from, to) {
+    const a = parseLengthTarget(from);
+    const b = parseLengthTarget(to);
+    if (a.kind === 'auto' || b.kind === 'auto')
+        return true;
+    if (a.kind === 'calc' || b.kind === 'calc')
+        return true;
+    // Same relative unit family → the pin returns immediately (no measure).
+    if (a.kind === 'percent' && b.kind === 'percent')
+        return false;
+    if (a.kind === 'vw' && b.kind === 'vw')
+        return false;
+    if (a.kind === 'vh' && b.kind === 'vh')
+        return false;
+    if (a.kind === 'percent' || b.kind === 'percent')
+        return true;
+    if (a.kind === 'vw' || b.kind === 'vw' || a.kind === 'vh' || b.kind === 'vh')
+        return true;
+    // both px-family
+    return familyOf(a) !== familyOf(b);
+}

package/dist/value-types/measure-resolve.d.cts

@@ -0,0 +1,91 @@
+import { parseNumeric } from "./numeric.cjs";
+/** Host-measured geometry the pure resolver needs. Drivers fill this from onLayout / viewport. */
+export interface LengthLayoutContext {
+    readonly parentWidth?: number;
+    readonly parentHeight?: number;
+    readonly viewportWidth?: number;
+    readonly viewportHeight?: number;
+    /** Content-box size when the element is laid out at height/width:auto. */
+    readonly autoWidth?: number;
+    readonly autoHeight?: number;
+}
+export type PositionalLengthAxis = 'width' | 'height' | 'top' | 'right' | 'bottom' | 'left' | 'x' | 'y';
+/** The positional keys whose length STRINGS any engine may measure-resolve (REQ-VALUETYPE-013). */
+export declare const POSITIONAL_LENGTH_AXES: readonly PositionalLengthAxis[];
+/** Runtime membership of the positional length axis set (cross-engine, one authority). */
+export declare function isPositionalLengthAxis(key: string): key is PositionalLengthAxis;
+/**
+ * The ONE key-aware executable value matrix (review fe5d455ffde7 / 91d41675d511): a
+ * measure-resolved length string (scalar, or any keyframe element — a null FIRST element is the
+ * legal from-current marker) executes only on the positional keys, and `auto` only for
+ * width/height (the intrinsic content measure; the positional-auto remainder stays loud).
+ * Returns the named refusal, or null when the value rides another lane (number, non-string) or
+ * is executable. Used by every supplying boundary: core target validation (web + native), the
+ * variants dictionary gate, the gesture-state gate, and the style-base gate.
+ */
+export declare function executableLengthValueRefusal(key: string, value: unknown): string | null;
+export type ParsedLengthTarget = {
+    readonly kind: 'px';
+    readonly value: number;
+} | {
+    readonly kind: 'percent';
+    readonly value: number;
+} | {
+    readonly kind: 'vw';
+    readonly value: number;
+} | {
+    readonly kind: 'vh';
+    readonly value: number;
+} | {
+    readonly kind: 'auto';
+} | {
+    readonly kind: 'calc';
+    readonly raw: string;
+    readonly left: ParsedLengthTarget;
+    readonly op: '+' | '-';
+    readonly right: ParsedLengthTarget;
+};
+export declare function isAuto(raw: string): boolean;
+/**
+ * Calc prefix detection (REQ-VALUETYPE-013): match `calc(` regardless of trailing `)`.
+ * Malformed/unclosed calc must NOT fall through to complex partial tokenization — parse
+ * routes it to a named refusal.
+ */
+export declare function isCalc(raw: string): boolean;
+/** Missing layout-geometry failures — typed so host severity can branch without message regex. */
+export type MeasureResolveContextReason = 'missing-element-measure' | 'missing-parent' | 'missing-viewport' | 'unsupported-axis-auto' | 'non-finite-result';
+export declare class MeasureResolveContextError extends Error {
+    readonly reason: MeasureResolveContextReason;
+    readonly axis: PositionalLengthAxis;
+    constructor(message: string, reason: MeasureResolveContextReason, axis: PositionalLengthAxis);
+}
+/** Verdict-shaped parse (no throw) for the validateTarget boundary (return-shaped refusals). */
+export type LengthTargetParseVerdict = {
+    readonly parsed: ParsedLengthTarget;
+    readonly refusal: null;
+} | {
+    readonly parsed: null;
+    readonly refusal: string;
+};
+export declare function parseLengthTargetVerdict(raw: string | number): LengthTargetParseVerdict;
+/** Parse a single length term used inside simple calc or as a standalone target. */
+export declare function parseLengthTarget(raw: string | number): ParsedLengthTarget;
+/**
+ * Total predicate: whether `raw` is a measure-resolved length form (no throw).
+ * Drivers use this at recognition boundaries — never bare try/catch over parseLengthTarget
+ * (unexpected faults must not be classified as “not a length”).
+ */
+export declare function isLengthTarget(raw: string | number): boolean;
+/**
+ * Resolve a length target to px using host layout context (Motion measure-then-mix law).
+ * Pure: all geometry arrives in `ctx`.
+ */
+export declare function resolveLengthToPx(raw: string | number, axis: PositionalLengthAxis, ctx: LengthLayoutContext): number;
+/**
+ * Motion needsMeasurement — the pin's family decision (review ae0a42832d85): the SAME relative
+ * unit family returns WITHOUT a measure (%→%, vw→vw, vh→vh interpolate on the unit lane — on
+ * native, measured-endpoint animation per the recorded divergence, never a unit-string
+ * generator). auto and calc always measure; mixed families measure.
+ */
+export declare function needsLengthMeasureResolve(from: string | number, to: string | number): boolean;
+export { parseNumeric };

package/dist/value-types/measure-resolve.d.ts

@@ -0,0 +1,91 @@
+import { parseNumeric } from "./numeric.js";
+/** Host-measured geometry the pure resolver needs. Drivers fill this from onLayout / viewport. */
+export interface LengthLayoutContext {
+    readonly parentWidth?: number;
+    readonly parentHeight?: number;
+    readonly viewportWidth?: number;
+    readonly viewportHeight?: number;
+    /** Content-box size when the element is laid out at height/width:auto. */
+    readonly autoWidth?: number;
+    readonly autoHeight?: number;
+}
+export type PositionalLengthAxis = 'width' | 'height' | 'top' | 'right' | 'bottom' | 'left' | 'x' | 'y';
+/** The positional keys whose length STRINGS any engine may measure-resolve (REQ-VALUETYPE-013). */
+export declare const POSITIONAL_LENGTH_AXES: readonly PositionalLengthAxis[];
+/** Runtime membership of the positional length axis set (cross-engine, one authority). */
+export declare function isPositionalLengthAxis(key: string): key is PositionalLengthAxis;
+/**
+ * The ONE key-aware executable value matrix (review fe5d455ffde7 / 91d41675d511): a
+ * measure-resolved length string (scalar, or any keyframe element — a null FIRST element is the
+ * legal from-current marker) executes only on the positional keys, and `auto` only for
+ * width/height (the intrinsic content measure; the positional-auto remainder stays loud).
+ * Returns the named refusal, or null when the value rides another lane (number, non-string) or
+ * is executable. Used by every supplying boundary: core target validation (web + native), the
+ * variants dictionary gate, the gesture-state gate, and the style-base gate.
+ */
+export declare function executableLengthValueRefusal(key: string, value: unknown): string | null;
+export type ParsedLengthTarget = {
+    readonly kind: 'px';
+    readonly value: number;
+} | {
+    readonly kind: 'percent';
+    readonly value: number;
+} | {
+    readonly kind: 'vw';
+    readonly value: number;
+} | {
+    readonly kind: 'vh';
+    readonly value: number;
+} | {
+    readonly kind: 'auto';
+} | {
+    readonly kind: 'calc';
+    readonly raw: string;
+    readonly left: ParsedLengthTarget;
+    readonly op: '+' | '-';
+    readonly right: ParsedLengthTarget;
+};
+export declare function isAuto(raw: string): boolean;
+/**
+ * Calc prefix detection (REQ-VALUETYPE-013): match `calc(` regardless of trailing `)`.
+ * Malformed/unclosed calc must NOT fall through to complex partial tokenization — parse
+ * routes it to a named refusal.
+ */
+export declare function isCalc(raw: string): boolean;
+/** Missing layout-geometry failures — typed so host severity can branch without message regex. */
+export type MeasureResolveContextReason = 'missing-element-measure' | 'missing-parent' | 'missing-viewport' | 'unsupported-axis-auto' | 'non-finite-result';
+export declare class MeasureResolveContextError extends Error {
+    readonly reason: MeasureResolveContextReason;
+    readonly axis: PositionalLengthAxis;
+    constructor(message: string, reason: MeasureResolveContextReason, axis: PositionalLengthAxis);
+}
+/** Verdict-shaped parse (no throw) for the validateTarget boundary (return-shaped refusals). */
+export type LengthTargetParseVerdict = {
+    readonly parsed: ParsedLengthTarget;
+    readonly refusal: null;
+} | {
+    readonly parsed: null;
+    readonly refusal: string;
+};
+export declare function parseLengthTargetVerdict(raw: string | number): LengthTargetParseVerdict;
+/** Parse a single length term used inside simple calc or as a standalone target. */
+export declare function parseLengthTarget(raw: string | number): ParsedLengthTarget;
+/**
+ * Total predicate: whether `raw` is a measure-resolved length form (no throw).
+ * Drivers use this at recognition boundaries — never bare try/catch over parseLengthTarget
+ * (unexpected faults must not be classified as “not a length”).
+ */
+export declare function isLengthTarget(raw: string | number): boolean;
+/**
+ * Resolve a length target to px using host layout context (Motion measure-then-mix law).
+ * Pure: all geometry arrives in `ctx`.
+ */
+export declare function resolveLengthToPx(raw: string | number, axis: PositionalLengthAxis, ctx: LengthLayoutContext): number;
+/**
+ * Motion needsMeasurement — the pin's family decision (review ae0a42832d85): the SAME relative
+ * unit family returns WITHOUT a measure (%→%, vw→vw, vh→vh interpolate on the unit lane — on
+ * native, measured-endpoint animation per the recorded divergence, never a unit-string
+ * generator). auto and calc always measure; mixed families measure.
+ */
+export declare function needsLengthMeasureResolve(from: string | number, to: string | number): boolean;
+export { parseNumeric };