css-calipers 1.0.0 → 1.1.0-beta.0

package/dist/esm/css-values/spec.js

@@ -0,0 +1,194 @@
+/**
+ * Helper that ties a row's `name`, `cssProperty`, and `keywords` together while
+ * inferring each as a literal. Authoring a row through `row(...)` keeps `name`
+ * and `keywords` as literals (so the helper map key and keyword param stay
+ * precise) without sprinkling `as const` on every entry.
+ */
+const row = (entry) => entry;
+/**
+ * The css-value spec table: one row per single-value property. The factory in
+ * `./cssValues.ts` generates a typed helper from each row, so adding a property
+ * is a one-line table edit, not a hand-written function.
+ *
+ * Sourced from `docs/css-number-value-types.md`. Multi-value properties and
+ * those lacking a clean single-value mapping (e.g. `maxLines`, the counter
+ * trio, grid lines, `scale`, `tabSize`) are intentionally excluded.
+ */
+export const CSS_VALUE_SPEC = [
+    // Opacity family: float, [0, 1], no keywords.
+    row({
+        name: 'opacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'Opacity',
+    }),
+    row({
+        name: 'fillOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'FillOpacity',
+    }),
+    row({
+        name: 'strokeOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'StrokeOpacity',
+    }),
+    row({
+        name: 'stopOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'StopOpacity',
+    }),
+    row({
+        name: 'floodOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'FloodOpacity',
+    }),
+    row({
+        name: 'shapeImageThreshold',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'ShapeImageThreshold',
+    }),
+    // Float, >= 0.
+    row({
+        name: 'lineHeight',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'normal',
+        ],
+        cssProperty: 'LineHeight',
+    }),
+    row({
+        name: 'flexGrow',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'FlexGrow',
+    }),
+    row({
+        name: 'flexShrink',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'FlexShrink',
+    }),
+    row({
+        name: 'animationIterationCount',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'infinite',
+        ],
+        cssProperty: 'AnimationIterationCount',
+    }),
+    row({
+        name: 'fontSizeAdjust',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'none',
+            'from-font',
+        ],
+        cssProperty: 'FontSizeAdjust',
+    }),
+    row({
+        name: 'zoom',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'Zoom',
+    }),
+    // Float, specific range.
+    row({
+        name: 'fontWeight',
+        kind: 'float',
+        min: 1,
+        max: 1000,
+        keywords: [
+            'normal',
+            'bold',
+            'lighter',
+            'bolder',
+        ],
+        cssProperty: 'FontWeight',
+    }),
+    row({
+        name: 'strokeMiterlimit',
+        kind: 'float',
+        min: 1,
+        keywords: [],
+        cssProperty: 'StrokeMiterlimit',
+    }),
+    // Integer, unbounded (negatives allowed).
+    row({
+        name: 'zIndex',
+        kind: 'int',
+        keywords: [
+            'auto',
+        ],
+        cssProperty: 'ZIndex',
+    }),
+    row({
+        name: 'order',
+        kind: 'int',
+        keywords: [],
+        cssProperty: 'Order',
+    }),
+    row({
+        name: 'mathDepth',
+        kind: 'int',
+        keywords: [
+            'auto-add',
+        ],
+        cssProperty: 'MathDepth',
+    }),
+    // Integer, min 1.
+    row({
+        name: 'columnCount',
+        kind: 'int',
+        min: 1,
+        keywords: [
+            'auto',
+        ],
+        cssProperty: 'ColumnCount',
+    }),
+    row({
+        name: 'orphans',
+        kind: 'int',
+        min: 1,
+        keywords: [],
+        cssProperty: 'Orphans',
+    }),
+    row({
+        name: 'widows',
+        kind: 'int',
+        min: 1,
+        keywords: [],
+        cssProperty: 'Widows',
+    }),
+    row({
+        name: 'lineClamp',
+        kind: 'int',
+        min: 1,
+        keywords: [
+            'none',
+        ],
+        cssProperty: 'WebkitLineClamp',
+    }),
+];

package/dist/esm/default.d.ts

@@ -0,0 +1,267 @@
+export declare const m: {
+    (value: number): import("./core").InscribedMeasurement<"px">;
+    (value: number, options: {
+        context?: string;
+    }): import("./core").InscribedMeasurement<"px">;
+    <Unit extends string>(value: number, unit: Unit, context?: string): import("./core").InscribedMeasurement<Lowercase<Unit>>;
+    <Unit extends string>(value: number, options: {
+        unit?: Unit | undefined;
+        context?: string;
+    }): import("./core").InscribedMeasurement<Lowercase<Unit>>;
+}, isMeasurement: (x: unknown) => x is import("./core").IMeasurement<string>, assertMatchingUnits: <Unit extends string>(left: import("./core").IMeasurement<Unit>, right: import("./core").IMeasurement<Unit>, context: string) => void, measurementMin: <Unit extends string>(a: import("./core").IMeasurement<Unit>, b: import("./core").IMeasurement<NoInfer<Unit>>) => import("./core").IMeasurement<Unit>, measurementMax: <Unit extends string>(a: import("./core").IMeasurement<Unit>, b: import("./core").IMeasurement<NoInfer<Unit>>) => import("./core").IMeasurement<Unit>, measurementUnitMetadata: {
+    readonly mPercent: {
+        readonly unit: "%";
+        readonly category: "percent";
+    };
+    readonly mPx: {
+        readonly unit: "px";
+        readonly category: "length-absolute";
+    };
+    readonly mCm: {
+        readonly unit: "cm";
+        readonly category: "length-absolute";
+    };
+    readonly mMm: {
+        readonly unit: "mm";
+        readonly category: "length-absolute";
+    };
+    readonly mQ: {
+        readonly unit: "q";
+        readonly category: "length-absolute";
+    };
+    readonly mIn: {
+        readonly unit: "in";
+        readonly category: "length-absolute";
+    };
+    readonly mPc: {
+        readonly unit: "pc";
+        readonly category: "length-absolute";
+    };
+    readonly mPt: {
+        readonly unit: "pt";
+        readonly category: "length-absolute";
+    };
+    readonly mEm: {
+        readonly unit: "em";
+        readonly category: "length-font-relative";
+    };
+    readonly mRem: {
+        readonly unit: "rem";
+        readonly category: "length-font-relative";
+    };
+    readonly mEx: {
+        readonly unit: "ex";
+        readonly category: "length-font-relative";
+    };
+    readonly mRex: {
+        readonly unit: "rex";
+        readonly category: "length-font-relative";
+    };
+    readonly mCh: {
+        readonly unit: "ch";
+        readonly category: "length-font-relative";
+    };
+    readonly mRch: {
+        readonly unit: "rch";
+        readonly category: "length-font-relative";
+    };
+    readonly mCap: {
+        readonly unit: "cap";
+        readonly category: "length-font-relative";
+    };
+    readonly mRcap: {
+        readonly unit: "rcap";
+        readonly category: "length-font-relative";
+    };
+    readonly mIc: {
+        readonly unit: "ic";
+        readonly category: "length-font-relative";
+    };
+    readonly mRic: {
+        readonly unit: "ric";
+        readonly category: "length-font-relative";
+    };
+    readonly mLh: {
+        readonly unit: "lh";
+        readonly category: "length-font-relative";
+    };
+    readonly mRlh: {
+        readonly unit: "rlh";
+        readonly category: "length-font-relative";
+    };
+    readonly mVw: {
+        readonly unit: "vw";
+        readonly category: "length-viewport";
+    };
+    readonly mVh: {
+        readonly unit: "vh";
+        readonly category: "length-viewport";
+    };
+    readonly mVi: {
+        readonly unit: "vi";
+        readonly category: "length-viewport";
+    };
+    readonly mVb: {
+        readonly unit: "vb";
+        readonly category: "length-viewport";
+    };
+    readonly mVmin: {
+        readonly unit: "vmin";
+        readonly category: "length-viewport";
+    };
+    readonly mVmax: {
+        readonly unit: "vmax";
+        readonly category: "length-viewport";
+    };
+    readonly mSvw: {
+        readonly unit: "svw";
+        readonly category: "length-viewport-small";
+    };
+    readonly mSvh: {
+        readonly unit: "svh";
+        readonly category: "length-viewport-small";
+    };
+    readonly mSvi: {
+        readonly unit: "svi";
+        readonly category: "length-viewport-small";
+    };
+    readonly mSvb: {
+        readonly unit: "svb";
+        readonly category: "length-viewport-small";
+    };
+    readonly mSvmin: {
+        readonly unit: "svmin";
+        readonly category: "length-viewport-small";
+    };
+    readonly mSvmax: {
+        readonly unit: "svmax";
+        readonly category: "length-viewport-small";
+    };
+    readonly mLvw: {
+        readonly unit: "lvw";
+        readonly category: "length-viewport-large";
+    };
+    readonly mLvh: {
+        readonly unit: "lvh";
+        readonly category: "length-viewport-large";
+    };
+    readonly mLvi: {
+        readonly unit: "lvi";
+        readonly category: "length-viewport-large";
+    };
+    readonly mLvb: {
+        readonly unit: "lvb";
+        readonly category: "length-viewport-large";
+    };
+    readonly mLvmin: {
+        readonly unit: "lvmin";
+        readonly category: "length-viewport-large";
+    };
+    readonly mLvmax: {
+        readonly unit: "lvmax";
+        readonly category: "length-viewport-large";
+    };
+    readonly mDvw: {
+        readonly unit: "dvw";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mDvh: {
+        readonly unit: "dvh";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mDvi: {
+        readonly unit: "dvi";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mDvb: {
+        readonly unit: "dvb";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mDvmin: {
+        readonly unit: "dvmin";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mDvmax: {
+        readonly unit: "dvmax";
+        readonly category: "length-viewport-dynamic";
+    };
+    readonly mCqw: {
+        readonly unit: "cqw";
+        readonly category: "length-container";
+    };
+    readonly mCqh: {
+        readonly unit: "cqh";
+        readonly category: "length-container";
+    };
+    readonly mCqi: {
+        readonly unit: "cqi";
+        readonly category: "length-container";
+    };
+    readonly mCqb: {
+        readonly unit: "cqb";
+        readonly category: "length-container";
+    };
+    readonly mCqmin: {
+        readonly unit: "cqmin";
+        readonly category: "length-container";
+    };
+    readonly mCqmax: {
+        readonly unit: "cqmax";
+        readonly category: "length-container";
+    };
+    readonly mDeg: {
+        readonly unit: "deg";
+        readonly category: "angle";
+    };
+    readonly mRad: {
+        readonly unit: "rad";
+        readonly category: "angle";
+    };
+    readonly mGrad: {
+        readonly unit: "grad";
+        readonly category: "angle";
+    };
+    readonly mTurn: {
+        readonly unit: "turn";
+        readonly category: "angle";
+    };
+    readonly mS: {
+        readonly unit: "s";
+        readonly category: "time";
+    };
+    readonly mMs: {
+        readonly unit: "ms";
+        readonly category: "time";
+    };
+    readonly mHz: {
+        readonly unit: "hz";
+        readonly category: "frequency";
+    };
+    readonly mKhz: {
+        readonly unit: "khz";
+        readonly category: "frequency";
+    };
+    readonly mDpi: {
+        readonly unit: "dpi";
+        readonly category: "resolution";
+    };
+    readonly mDpcm: {
+        readonly unit: "dpcm";
+        readonly category: "resolution";
+    };
+    readonly mDppx: {
+        readonly unit: "dppx";
+        readonly category: "resolution";
+    };
+    readonly mFr: {
+        readonly unit: "fr";
+        readonly category: "flex";
+    };
+}, makeUnitHelper: <Unit extends string>(unit: Unit) => import("./core").UnitHelper<Unit>, makeUnitHelperFromDefinition: <Name extends import("./unitDefinitions").UnitHelperName>(name: Name) => import("./core").UnitHelper<import("./unitDefinitions").UnitDefinitionRecord[Name]["unit"]>, makeUnitGuard: <T extends import("./core").UnitHelper>(helper: T) => import("./core").UnitGuard<T>, makeUnitAssert: <T extends import("./core").UnitHelper>(helper: T) => import("./core").UnitAssertion<T>, hasCssMethod: (x: unknown) => x is {
+    css: () => string;
+}, assertUnit: <Unit extends string>(measurement: import("./core").IMeasurement<Unit>, expectedUnit: string, context?: string) => void, assertCondition: (condition: boolean | (() => boolean), message: string) => void, makeMeasurementRefinement: <B>(spec: {
+    predicate: (value: number) => boolean;
+    message: (measurement: import("./core").IMeasurement) => string;
+    defaultFallback?: number;
+}) => import("./core").MeasurementRefinement<B>, nonNegative: import("./core").MeasurementRefinement<import("./core").GreaterOrEqualToZeroBrand>, nonPositive: import("./core").MeasurementRefinement<import("./core").SmallerOrEqualToZeroBrand>, inRange: <Min extends number, Max extends number>(min: Min, max: Max) => import("./core").MeasurementRefinement<import("./core").InRangeBrand<Min, Max>>, getErrorConfig: () => Required<import("./core").ErrorConfig>, setErrorConfig: (next: import("./core").ErrorConfig) => void;
+//# sourceMappingURL=default.d.ts.map

package/dist/esm/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/default.ts"],"names":[],"mappings":"AAeA,eAAO,MACL,CAAC;;;eAoBs9O,CAAC;;;;;;;GAnBx9O,aAAa,8DACb,mBAAmB,yIACnB,cAAc,yJACd,cAAc,yJACd,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GACvB,cAAc,0EACd,4BAA4B,uGAaqgU,sDAA0B,WAZ3jU,aAAa,uFACb,cAAc,2FACd,YAAY;;GACZ,UAAU,2HACV,eAAe,mEACf,yBAAyB;;;mBAOg0Z,CAAC;iDAN11Z,WAAW,sFACX,WAAW,sFACX,OAAO,mJACP,cAAc,gDACd,cAAc,8CACG,CAAC"}

package/dist/esm/default.js

@@ -0,0 +1,14 @@
+// THE DEFAULT INSTANCE. This module sits ABOVE both `core.ts` and `factory.ts`
+// and is the single place where the package's bare, default-instance helpers are
+// assembled. It calls the public factory `createCalipers()` at its defaults, so
+// the bare `m` / refinements / unit-helper builders below are exactly the same
+// construction path a consumer gets from `createCalipers()` with no config. The
+// default can no longer drift from a custom instance, because there is one path.
+//
+// `factory.ts` depends only on the `internal/*` builders (which import nothing
+// but TYPES from `core.ts`), so importing the factory here introduces no runtime
+// import cycle: `default.ts -> factory.ts -> internal/* -> core.ts (types only)`.
+// `core.ts` itself imports nothing from this module.
+import { createCalipers } from './factory';
+const defaultCalipers = createCalipers();
+export const { m, isMeasurement, assertMatchingUnits, measurementMin, measurementMax, measurementUnitMetadata, makeUnitHelper, makeUnitHelperFromDefinition, makeUnitGuard, makeUnitAssert, hasCssMethod, assertUnit, assertCondition, makeMeasurementRefinement, nonNegative, nonPositive, inRange, getErrorConfig, setErrorConfig, } = defaultCalipers;

package/dist/esm/factory.d.ts

@@ -1,6 +1,6 @@
-import { type ErrorConfig } from './internal/errors';
 import { type CoreApi } from './internal/createCoreApi';
 import { type UnitsApi } from './internal/createUnitsApi';
+import { type ErrorConfig } from './internal/errors';
 export type CalipersFactoryConfig = {
     errorConfig?: ErrorConfig;
 };

package/dist/esm/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE1E,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,GACpC,QAAQ,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAEJ,eAAO,MAAM,cAAc,GACzB,SAAQ,qBAA0B,KACjC,gBAYF,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAEL,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,GACpC,QAAQ,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAEJ,eAAO,MAAM,cAAc,GACzB,SAAQ,qBAA0B,KACjC,gBAUF,CAAC"}

package/dist/esm/factory.js

@@ -1,6 +1,6 @@
-import { createErrorConfigStore } from './internal/errors';
-import { createCoreApi } from './internal/createCoreApi';
-import { createUnitsApi } from './internal/createUnitsApi';
+import { createCoreApi, } from './internal/createCoreApi';
+import { createUnitsApi, } from './internal/createUnitsApi';
+import { createErrorConfigStore, } from './internal/errors';
 export const createCalipers = (config = {}) => {
     var _a;
     const errorStore = createErrorConfigStore((_a = config.errorConfig) !== null && _a !== void 0 ? _a : {});

package/dist/esm/float.d.ts

@@ -0,0 +1,35 @@
+import { type Scalar } from './scalar';
+export type FloatConstraints = {
+    min?: number;
+    max?: number;
+};
+export type FloatOptions = FloatConstraints & {
+    context?: string;
+};
+export interface IFloat {
+    css: () => string;
+    toString: () => string;
+    valueOf: () => number;
+    value: () => number;
+    constraints: () => FloatConstraints;
+    withValue: (value: number) => IFloat;
+    add: (delta: Scalar) => IFloat;
+    subtract: (delta: Scalar) => IFloat;
+    multiply: (factor: Scalar) => IFloat;
+    divide: (divisor: Scalar) => IFloat;
+    clamp: (min: number, max: number) => IFloat;
+}
+/**
+ * Create a typed float (a finite, unitless real number) with optional range
+ * constraints. Operations re-validate against the same constraints, so a
+ * hardened float stays hardened (or throws) through arithmetic.
+ */
+export declare function f(value: number, options?: FloatOptions): IFloat;
+/**
+ * Bind a set of float constraints once and reuse the bound factory, the scalar
+ * analogue of `makeUnitHelper`. For example, an opacity value is
+ * `hardenFloat({ min: 0, max: 1 })`.
+ */
+export declare const hardenFloat: (constraints?: FloatConstraints) => (value: number, context?: string) => IFloat;
+export declare const isFloat: (value: unknown) => value is IFloat;
+//# sourceMappingURL=float.d.ts.map

package/dist/esm/float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float.d.ts","sourceRoot":"","sources":["../../src/float.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,UAAU,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,gBAAgB,CAAC;IACpC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;AA2GD;;;;GAIG;AACH,wBAAgB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAEnE;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,GACrB,cAAa,gBAAqB,MAClC,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MACgB,CAAC;AAEtD,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACtB,CAAC"}

package/dist/esm/float.js

@@ -0,0 +1,104 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FloatImpl_instances, _FloatImpl_value, _FloatImpl_min, _FloatImpl_max, _FloatImpl_context, _FloatImpl_options;
+import { toPlainDecimal } from './internal/toPlainDecimal';
+import { toNumber } from './scalar';
+const suffix = (context) => context ? ` [${context}]` : '';
+const coerce = (value) => toNumber(value);
+class FloatImpl {
+    constructor(value, options = {}) {
+        _FloatImpl_instances.add(this);
+        _FloatImpl_value.set(this, void 0);
+        _FloatImpl_min.set(this, void 0);
+        _FloatImpl_max.set(this, void 0);
+        _FloatImpl_context.set(this, void 0);
+        const { min, max, context } = options;
+        if (min !== undefined && max !== undefined && min > max) {
+            throw new Error(`f: min (${min}) must be <= max (${max})${suffix(context)}`);
+        }
+        if (!Number.isFinite(value)) {
+            throw new Error(`f: expected a finite number (got ${value})${suffix(context)}`);
+        }
+        if (min !== undefined && value < min) {
+            throw new Error(`f: ${value} is below the minimum ${min}${suffix(context)}`);
+        }
+        if (max !== undefined && value > max) {
+            throw new Error(`f: ${value} is above the maximum ${max}${suffix(context)}`);
+        }
+        __classPrivateFieldSet(this, _FloatImpl_value, value, "f");
+        __classPrivateFieldSet(this, _FloatImpl_min, min, "f");
+        __classPrivateFieldSet(this, _FloatImpl_max, max, "f");
+        __classPrivateFieldSet(this, _FloatImpl_context, context, "f");
+    }
+    value() {
+        return __classPrivateFieldGet(this, _FloatImpl_value, "f");
+    }
+    valueOf() {
+        return __classPrivateFieldGet(this, _FloatImpl_value, "f");
+    }
+    constraints() {
+        return { min: __classPrivateFieldGet(this, _FloatImpl_min, "f"), max: __classPrivateFieldGet(this, _FloatImpl_max, "f") };
+    }
+    css() {
+        return toPlainDecimal(__classPrivateFieldGet(this, _FloatImpl_value, "f"));
+    }
+    toString() {
+        return this.css();
+    }
+    withValue(value) {
+        return new FloatImpl(value, __classPrivateFieldGet(this, _FloatImpl_instances, "m", _FloatImpl_options).call(this));
+    }
+    add(delta) {
+        return this.withValue(__classPrivateFieldGet(this, _FloatImpl_value, "f") + coerce(delta));
+    }
+    subtract(delta) {
+        return this.withValue(__classPrivateFieldGet(this, _FloatImpl_value, "f") - coerce(delta));
+    }
+    multiply(factor) {
+        return this.withValue(__classPrivateFieldGet(this, _FloatImpl_value, "f") * coerce(factor));
+    }
+    divide(divisor) {
+        const numeric = coerce(divisor);
+        if (numeric === 0) {
+            throw new Error(`f: cannot divide ${__classPrivateFieldGet(this, _FloatImpl_value, "f")} by zero${suffix(__classPrivateFieldGet(this, _FloatImpl_context, "f"))}`);
+        }
+        const result = __classPrivateFieldGet(this, _FloatImpl_value, "f") / numeric;
+        if (!Number.isFinite(result)) {
+            throw new Error(`f: non-finite result dividing ${__classPrivateFieldGet(this, _FloatImpl_value, "f")} by ${numeric}${suffix(__classPrivateFieldGet(this, _FloatImpl_context, "f"))}`);
+        }
+        return this.withValue(result);
+    }
+    clamp(min, max) {
+        if (min > max) {
+            throw new Error(`f.clamp: min (${min}) must be <= max (${max})`);
+        }
+        return this.withValue(Math.min(max, Math.max(min, __classPrivateFieldGet(this, _FloatImpl_value, "f"))));
+    }
+}
+_FloatImpl_value = new WeakMap(), _FloatImpl_min = new WeakMap(), _FloatImpl_max = new WeakMap(), _FloatImpl_context = new WeakMap(), _FloatImpl_instances = new WeakSet(), _FloatImpl_options = function _FloatImpl_options() {
+    return { min: __classPrivateFieldGet(this, _FloatImpl_min, "f"), max: __classPrivateFieldGet(this, _FloatImpl_max, "f"), context: __classPrivateFieldGet(this, _FloatImpl_context, "f") };
+};
+/**
+ * Create a typed float (a finite, unitless real number) with optional range
+ * constraints. Operations re-validate against the same constraints, so a
+ * hardened float stays hardened (or throws) through arithmetic.
+ */
+export function f(value, options = {}) {
+    return new FloatImpl(value, options);
+}
+/**
+ * Bind a set of float constraints once and reuse the bound factory, the scalar
+ * analogue of `makeUnitHelper`. For example, an opacity value is
+ * `hardenFloat({ min: 0, max: 1 })`.
+ */
+export const hardenFloat = (constraints = {}) => (value, context) => new FloatImpl(value, { ...constraints, context });
+export const isFloat = (value) => value instanceof FloatImpl;

package/dist/esm/index.d.ts

@@ -1,15 +1,17 @@
 export * from './core';
-export * from './units/percent';
+export * from './default';
+export { type CascadeKeyword, color, type ColorConfig, type ColorFormatPlugin, colorFormats, type ColorInput, type ColorObject, type ColorSpace, type ColorSpaceDescriptor, type Store as ColorStore, type ColorString, createColor, type CreateColorConfig, type CssColor, type CssFormat, type CurrentColor, type CustomColor, defaultColorConfig, defaultFormatPriority, defineColorSpace, type DeprecatedSystemColor, type FormatName, type Gamut, parseColor, resolve as resolveColor, type ResolvedColor, storeColor, type Strictness, type SymbolicColor, type SystemColor, type TransparentRendering, } from './color';
 export * from './units/absolute';
-export * from './units/font-relative';
-export * from './units/viewport';
-export * from './units/viewport-small';
-export * from './units/viewport-large';
-export * from './units/viewport-dynamic';
-export * from './units/container';
 export * from './units/angle';
-export * from './units/time';
+export * from './units/container';
+export * from './units/font-relative';
 export * from './units/frequency';
-export * from './units/resolution';
 export * from './units/grid';
+export * from './units/percent';
+export * from './units/resolution';
+export * from './units/time';
+export * from './units/viewport';
+export * from './units/viewport-dynamic';
+export * from './units/viewport-large';
+export * from './units/viewport-small';
 //# sourceMappingURL=index.d.ts.map