css-calipers 0.15.0 → 1.1.0-beta.0

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AAEvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AAIvB,cAAc,WAAW,CAAC;AAM1B,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,oBAAoB,EACzB,KAAK,KAAK,IAAI,UAAU,EACxB,KAAK,WAAW,EAChB,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,UAAU,EACf,KAAK,KAAK,EACV,UAAU,EACV,OAAO,IAAI,YAAY,EACvB,KAAK,aAAa,EAClB,UAAU,EACV,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,oBAAoB,GAC1B,MAAM,SAAS,CAAC;AACjB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dist/esm/index.js

@@ -1,14 +1,24 @@
 export * from './core';
-export * from './units/percent';
+// The bare default-instance helpers (`m`, refinements, unit-helper builders,
+// error-config accessors) come from the single construction path in `./default`,
+// which assembles them via `createCalipers()` at its defaults.
+export * from './default';
+// The native colour input, alongside `m()` / `r()` / `i()` / `f()`. The full value
+// surface also lives at the `./color` subpath (for bundler/node16 consumers); the root
+// re-exports it too so classic-resolution consumers (e.g. @css-bookends/color) can reach
+// it without a subpath. The lower-level value primitives are color-prefixed (and
+// `resolve` is re-exported as `resolveColor`) to avoid colliding with calipers' own names.
+export { color, colorFormats, createColor, defaultColorConfig, defaultFormatPriority, defineColorSpace, parseColor, resolve as resolveColor, storeColor, } 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';

package/dist/esm/integer.d.ts

@@ -0,0 +1,36 @@
+import { type Scalar } from './scalar';
+export type IntegerConstraints = {
+    min?: number;
+    max?: number;
+};
+export type IntegerOptions = IntegerConstraints & {
+    context?: string;
+};
+export interface IInteger {
+    css: () => string;
+    toString: () => string;
+    valueOf: () => number;
+    value: () => number;
+    constraints: () => IntegerConstraints;
+    withValue: (value: number) => IInteger;
+    add: (delta: Scalar) => IInteger;
+    subtract: (delta: Scalar) => IInteger;
+    multiply: (factor: Scalar) => IInteger;
+    divide: (divisor: Scalar) => IInteger;
+    clamp: (min: number, max: number) => IInteger;
+}
+/**
+ * Create a typed integer (a finite whole number) with optional range
+ * constraints. Operations re-validate against the same constraints, so a
+ * result that is no longer an integer (or falls out of range) throws. That is
+ * how integer-ness survives arithmetic.
+ */
+export declare function i(value: number, options?: IntegerOptions): IInteger;
+/**
+ * Bind a set of integer constraints once and reuse the bound factory, the
+ * scalar analogue of `makeUnitHelper`. For example, a font-weight value is
+ * `hardenInteger({ min: 1, max: 1000 })`.
+ */
+export declare const hardenInteger: (constraints?: IntegerConstraints) => (value: number, context?: string) => IInteger;
+export declare const isInteger: (value: unknown) => value is IInteger;
+//# sourceMappingURL=integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/integer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,UAAU,CAAC;AAEjD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,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,kBAAkB,CAAC;IACtC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;IACvC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;IACjC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;IACtC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,CAAC;IACvC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,QAAQ,CAAC;IACtC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,CAAC;CAC/C;AAgHD;;;;;GAKG;AACH,wBAAgB,CAAC,CACf,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,QAAQ,CAEV;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACvB,cAAa,kBAAuB,MACpC,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,QACkB,CAAC;AAExD,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QACtB,CAAC"}

package/dist/esm/integer.js

@@ -0,0 +1,108 @@
+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 _IntegerImpl_instances, _IntegerImpl_value, _IntegerImpl_min, _IntegerImpl_max, _IntegerImpl_context, _IntegerImpl_options;
+import { toPlainDecimal } from './internal/toPlainDecimal';
+import { toNumber } from './scalar';
+const suffix = (context) => context ? ` [${context}]` : '';
+const coerce = (value) => toNumber(value);
+class IntegerImpl {
+    constructor(value, options = {}) {
+        _IntegerImpl_instances.add(this);
+        _IntegerImpl_value.set(this, void 0);
+        _IntegerImpl_min.set(this, void 0);
+        _IntegerImpl_max.set(this, void 0);
+        _IntegerImpl_context.set(this, void 0);
+        const { min, max, context } = options;
+        if (min !== undefined && max !== undefined && min > max) {
+            throw new Error(`i: min (${min}) must be <= max (${max})${suffix(context)}`);
+        }
+        if (!Number.isFinite(value)) {
+            throw new Error(`i: expected a finite number (got ${value})${suffix(context)}`);
+        }
+        if (!Number.isInteger(value)) {
+            throw new Error(`i: expected an integer (got ${value})${suffix(context)}`);
+        }
+        if (min !== undefined && value < min) {
+            throw new Error(`i: ${value} is below the minimum ${min}${suffix(context)}`);
+        }
+        if (max !== undefined && value > max) {
+            throw new Error(`i: ${value} is above the maximum ${max}${suffix(context)}`);
+        }
+        __classPrivateFieldSet(this, _IntegerImpl_value, value, "f");
+        __classPrivateFieldSet(this, _IntegerImpl_min, min, "f");
+        __classPrivateFieldSet(this, _IntegerImpl_max, max, "f");
+        __classPrivateFieldSet(this, _IntegerImpl_context, context, "f");
+    }
+    value() {
+        return __classPrivateFieldGet(this, _IntegerImpl_value, "f");
+    }
+    valueOf() {
+        return __classPrivateFieldGet(this, _IntegerImpl_value, "f");
+    }
+    constraints() {
+        return { min: __classPrivateFieldGet(this, _IntegerImpl_min, "f"), max: __classPrivateFieldGet(this, _IntegerImpl_max, "f") };
+    }
+    css() {
+        return toPlainDecimal(__classPrivateFieldGet(this, _IntegerImpl_value, "f"));
+    }
+    toString() {
+        return this.css();
+    }
+    withValue(value) {
+        return new IntegerImpl(value, __classPrivateFieldGet(this, _IntegerImpl_instances, "m", _IntegerImpl_options).call(this));
+    }
+    add(delta) {
+        return this.withValue(__classPrivateFieldGet(this, _IntegerImpl_value, "f") + coerce(delta));
+    }
+    subtract(delta) {
+        return this.withValue(__classPrivateFieldGet(this, _IntegerImpl_value, "f") - coerce(delta));
+    }
+    multiply(factor) {
+        return this.withValue(__classPrivateFieldGet(this, _IntegerImpl_value, "f") * coerce(factor));
+    }
+    divide(divisor) {
+        const numeric = coerce(divisor);
+        if (numeric === 0) {
+            throw new Error(`i: cannot divide ${__classPrivateFieldGet(this, _IntegerImpl_value, "f")} by zero${suffix(__classPrivateFieldGet(this, _IntegerImpl_context, "f"))}`);
+        }
+        const result = __classPrivateFieldGet(this, _IntegerImpl_value, "f") / numeric;
+        if (!Number.isFinite(result)) {
+            throw new Error(`i: non-finite result dividing ${__classPrivateFieldGet(this, _IntegerImpl_value, "f")} by ${numeric}${suffix(__classPrivateFieldGet(this, _IntegerImpl_context, "f"))}`);
+        }
+        return this.withValue(result);
+    }
+    clamp(min, max) {
+        if (min > max) {
+            throw new Error(`i.clamp: min (${min}) must be <= max (${max})`);
+        }
+        return this.withValue(Math.min(max, Math.max(min, __classPrivateFieldGet(this, _IntegerImpl_value, "f"))));
+    }
+}
+_IntegerImpl_value = new WeakMap(), _IntegerImpl_min = new WeakMap(), _IntegerImpl_max = new WeakMap(), _IntegerImpl_context = new WeakMap(), _IntegerImpl_instances = new WeakSet(), _IntegerImpl_options = function _IntegerImpl_options() {
+    return { min: __classPrivateFieldGet(this, _IntegerImpl_min, "f"), max: __classPrivateFieldGet(this, _IntegerImpl_max, "f"), context: __classPrivateFieldGet(this, _IntegerImpl_context, "f") };
+};
+/**
+ * Create a typed integer (a finite whole number) with optional range
+ * constraints. Operations re-validate against the same constraints, so a
+ * result that is no longer an integer (or falls out of range) throws. That is
+ * how integer-ness survives arithmetic.
+ */
+export function i(value, options = {}) {
+    return new IntegerImpl(value, options);
+}
+/**
+ * Bind a set of integer constraints once and reuse the bound factory, the
+ * scalar analogue of `makeUnitHelper`. For example, a font-weight value is
+ * `hardenInteger({ min: 1, max: 1000 })`.
+ */
+export const hardenInteger = (constraints = {}) => (value, context) => new IntegerImpl(value, { ...constraints, context });
+export const isInteger = (value) => value instanceof IntegerImpl;

package/dist/esm/internal/buildMeasurementCreationError.tests.d.ts

@@ -1,3 +1,3 @@
-export { buildMeasurementCreationError } from './buildMeasurementCreationError';
 export type { MeasurementCreationErrorPayload } from './buildMeasurementCreationError';
+export { buildMeasurementCreationError } from './buildMeasurementCreationError';
 //# sourceMappingURL=buildMeasurementCreationError.tests.d.ts.map

package/dist/esm/internal/buildMeasurementCreationError.tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildMeasurementCreationError.tests.d.ts","sourceRoot":"","sources":["../../../src/internal/buildMeasurementCreationError.tests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,YAAY,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"buildMeasurementCreationError.tests.d.ts","sourceRoot":"","sources":["../../../src/internal/buildMeasurementCreationError.tests.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/esm/internal/createCoreApi.d.ts

@@ -1,6 +1,6 @@
+import type { GreaterOrEqualToZeroBrand, IMeasurement, InRangeBrand, InscribedMeasurement, MeasurementRefinement, SmallerOrEqualToZeroBrand, UnitAssertion, UnitGuard, UnitHelper } from '../core';
 import { type UnitDefinitionRecord, type UnitHelperName } from '../unitDefinitions';
 import { type ErrorConfigStore } from './errors';
-import type { InscribedMeasurement, IMeasurement, UnitAssertion, UnitGuard, UnitHelper } from '../core';
 type MeasurementCreateOptions<Unit extends string> = {
     unit?: Unit;
     context?: string;
@@ -277,6 +277,14 @@ export declare const createCoreApi: (errorStore: ErrorConfigStore) => {
     };
     readonly assertUnit: <Unit extends string>(measurement: IMeasurement<Unit>, expectedUnit: string, context?: string) => void;
     readonly assertCondition: (condition: boolean | (() => boolean), message: string) => void;
+    readonly makeMeasurementRefinement: <B>(spec: {
+        predicate: (value: number) => boolean;
+        message: (measurement: IMeasurement) => string;
+        defaultFallback?: number;
+    }) => MeasurementRefinement<B>;
+    readonly nonNegative: MeasurementRefinement<GreaterOrEqualToZeroBrand>;
+    readonly nonPositive: MeasurementRefinement<SmallerOrEqualToZeroBrand>;
+    readonly inRange: <Min extends number, Max extends number>(min: Min, max: Max) => MeasurementRefinement<InRangeBrand<Min, Max>>;
     readonly getErrorConfig: () => Required<import("./errors").ErrorConfig>;
     readonly setErrorConfig: (next: import("./errors").ErrorConfig) => void;
 };

package/dist/esm/internal/createCoreApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createCoreApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createCoreApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,SAAS,EACT,UAAU,EACX,MAAM,SAAS,CAAC;AAGjB,KAAK,wBAAwB,CAAC,IAAI,SAAS,MAAM,IAAI;IACnD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA8BF,eAAO,MAAM,aAAa,GAAI,YAAY,gBAAgB;;gBAwQtC,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC;gBAE5C,MAAM,WACJ;YAAE,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,GAC5B,oBAAoB,CAAC,IAAI,CAAC;SAClB,IAAI,SAAS,MAAM,SACrB,MAAM,QACP,IAAI,YACA,MAAM,GACf,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SAC7B,IAAI,SAAS,MAAM,SACrB,MAAM,WACJ,wBAAwB,CAAC,IAAI,CAAC,GACtC,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;;gCAhBnC,OAAO,KACT,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC;mCAlQC,IAAI,SAAS,MAAM,QACxC,YAAY,CAAC,IAAI,CAAC,SACjB,YAAY,CAAC,IAAI,CAAC,WAChB,MAAM,KACd,IAAI;8BA0YiB,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAC7B,YAAY,CAAC,IAAI,CAAC;8BAKG,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAC7B,YAAY,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAlEG,IAAI,SAAS,MAAM,QACnC,IAAI,KACT,UAAU,CAAC,IAAI,CAAC;4CAImB,IAAI,SAAS,cAAc,QACzD,IAAI,KACT,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;6BAS1B,CAAC,SAAS,UAAU,UACjC,CAAC,KACR,SAAS,CAAC,CAAC,CAAC;8BAKS,CAAC,SAAS,UAAU,UAClC,CAAC,KACR,aAAa,CAAC,CAAC,CAAC;+BAmBd,OAAO,KACT,CAAC,IAAI;QAAE,GAAG,EAAE,MAAM,MAAM,CAAA;KAAE;0BAyBT,IAAI,SAAS,MAAM,eACxB,YAAY,CAAC,IAAI,CAAC,gBACjB,MAAM,YACV,MAAM;0CAIL,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,WAC3B,MAAM,KACd,IAAI;;;CA8BR,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"createCoreApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createCoreApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,qBAAqB,EAGrB,yBAAyB,EACzB,aAAa,EACb,SAAS,EACT,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIrE,KAAK,wBAAwB,CAAC,IAAI,SAAS,MAAM,IAAI;IACnD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,YAAY,gBAAgB;;gBAyRtC,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC;gBAE5C,MAAM,WACJ;YAAE,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,GAC5B,oBAAoB,CAAC,IAAI,CAAC;SAClB,IAAI,SAAS,MAAM,SACrB,MAAM,QACP,IAAI,YACA,MAAM,GACf,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SAC7B,IAAI,SAAS,MAAM,SACrB,MAAM,WACJ,wBAAwB,CAAC,IAAI,CAAC,GACtC,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;;gCAhBd,OAAO,KAAG,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC;mCAlRhC,IAAI,SAAS,MAAM,QACxC,YAAY,CAAC,IAAI,CAAC,SACjB,YAAY,CAAC,IAAI,CAAC,WAChB,MAAM,KACd,IAAI;8BA4ZiB,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAC7B,YAAY,CAAC,IAAI,CAAC;8BAKG,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAC7B,YAAY,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAjEG,IAAI,SAAS,MAAM,QACnC,IAAI,KACT,UAAU,CAAC,IAAI,CAAC;4CAImB,IAAI,SAAS,cAAc,QACzD,IAAI,KACT,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;6BAM1B,CAAC,SAAS,UAAU,UACjC,CAAC,KACR,SAAS,CAAC,CAAC,CAAC;8BAKS,CAAC,SAAS,UAAU,UAClC,CAAC,KACR,aAAa,CAAC,CAAC,CAAC;+BAsBM,OAAO,KAAG,CAAC,IAAI;QAAE,GAAG,EAAE,MAAM,MAAM,CAAA;KAAE;0BAyBzC,IAAI,SAAS,MAAM,eACxB,YAAY,CAAC,IAAI,CAAC,gBACjB,MAAM,YACV,MAAM;0CAIL,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,WAC3B,MAAM,KACd,IAAI;yCAkB4B,CAAC,QAAQ;QAC1C,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;QACtC,OAAO,EAAE,CAAC,WAAW,EAAE,YAAY,KAAK,MAAM,CAAC;QAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,KAAG,qBAAqB,CAAC,CAAC,CAAC;;;uBA+EX,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,OAChD,GAAG,OACH,GAAG,KACP,qBAAqB,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;;CAkCjD,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/esm/internal/createCoreApi.js

@@ -9,35 +9,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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);
 };
+import { toNumber } from '../scalar';
 import { UNIT_DEFINITIONS, } from '../unitDefinitions';
 import { buildMeasurementCreationError } from './buildMeasurementCreationError';
-import { createErrorHelpers, } from './errors';
-// JS stringifies numbers in exponential form once the magnitude is >= 1e21 or
-// < 1e-6 (e.g. "1e+21", "1e-7"). CSS output must never contain that, so we
-// expand the exponent into a plain decimal by shifting the decimal point on the
-// digit string. This is string manipulation on the same digits, so it does not
-// re-introduce floating-point error.
-const toPlainDecimal = (value) => {
-    const text = `${value}`;
-    if (!text.includes('e') && !text.includes('E')) {
-        return text;
-    }
-    const [mantissa, exponentText] = text.toLowerCase().split('e');
-    const exponent = Number(exponentText);
-    const negative = mantissa.startsWith('-');
-    const unsigned = negative ? mantissa.slice(1) : mantissa;
-    const [intDigits, fracDigits = ''] = unsigned.split('.');
-    const digits = intDigits + fracDigits;
-    const pointFromLeft = intDigits.length + exponent;
-    const sign = negative ? '-' : '';
-    if (pointFromLeft <= 0) {
-        return `${sign}0.${'0'.repeat(-pointFromLeft)}${digits}`;
-    }
-    if (pointFromLeft >= digits.length) {
-        return `${sign}${digits}${'0'.repeat(pointFromLeft - digits.length)}`;
-    }
-    return `${sign}${digits.slice(0, pointFromLeft)}.${digits.slice(pointFromLeft)}`;
-};
+import { createErrorHelpers } from './errors';
+import { toPlainDecimal } from './toPlainDecimal';
 export const createCoreApi = (errorStore) => {
     var _Measurement_instances, _a, _Measurement_value, _Measurement_unit, _Measurement_clone;
     const { throwHelperError, throwMeasurementMethodError } = createErrorHelpers(errorStore);
@@ -47,7 +23,10 @@ export const createCoreApi = (errorStore) => {
         if (leftUnit !== rightUnit) {
             throwHelperError({
                 operation: 'css-calipers.assertMatchingUnits',
-                params: [left, right],
+                params: [
+                    left,
+                    right,
+                ],
                 message: `measurement unit mismatch: ${leftUnit} vs ${rightUnit}`,
                 context,
                 details: { code: 'CALIPERS_E_UNIT_MISMATCH' },
@@ -153,18 +132,20 @@ export const createCoreApi = (errorStore) => {
             return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
         }
         multiply(factor) {
-            if (factor === 1)
+            const numericFactor = toNumber(factor);
+            if (numericFactor === 1)
                 return this;
-            if (factor === 0)
+            if (numericFactor === 0)
                 return new _a(0, __classPrivateFieldGet(this, _Measurement_unit, "f"));
-            if (factor === -1)
+            if (numericFactor === -1)
                 return new _a(-__classPrivateFieldGet(this, _Measurement_value, "f"), __classPrivateFieldGet(this, _Measurement_unit, "f"));
-            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") * factor);
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") * numericFactor);
         }
         divide(divisor) {
-            if (divisor === 1)
+            const numericDivisor = toNumber(divisor);
+            if (numericDivisor === 1)
                 return this;
-            if (divisor === 0) {
+            if (numericDivisor === 0) {
                 throwMeasurementMethodError({
                     operation: 'css-calipers.Measurement.divide',
                     caller: this,
@@ -173,7 +154,7 @@ export const createCoreApi = (errorStore) => {
                     details: { code: 'CALIPERS_E_DIVIDE_BY_ZERO' },
                 });
             }
-            const result = __classPrivateFieldGet(this, _Measurement_value, "f") / divisor;
+            const result = __classPrivateFieldGet(this, _Measurement_value, "f") / numericDivisor;
             if (!Number.isFinite(result)) {
                 throwMeasurementMethodError({
                     operation: 'css-calipers.Measurement.divide',
@@ -195,6 +176,8 @@ export const createCoreApi = (errorStore) => {
             return shouldNegate ? __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, -__classPrivateFieldGet(this, _Measurement_value, "f")) : this;
         }
         absolute() {
+            // Math.abs is always >= 0, so the result is hardened to NonNegativeMeasurement
+            // (the governing rule: a runtime restriction must also harden the type).
             return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.abs(__classPrivateFieldGet(this, _Measurement_value, "f")));
         }
         round(precision = 0) {
@@ -218,7 +201,10 @@ export const createCoreApi = (errorStore) => {
                 throwMeasurementMethodError({
                     operation: 'css-calipers.Measurement.clamp',
                     caller: this,
-                    params: [min, max],
+                    params: [
+                        min,
+                        max,
+                    ],
                     message: 'clamp: expected finite bounds',
                     details: { code: 'CALIPERS_E_CLAMP_NONFINITE_BOUNDS' },
                 });
@@ -227,7 +213,10 @@ export const createCoreApi = (errorStore) => {
                 throwMeasurementMethodError({
                     operation: 'css-calipers.Measurement.clamp',
                     caller: this,
-                    params: [min, max],
+                    params: [
+                        min,
+                        max,
+                    ],
                     message: `clamp: min (${min.css()}) must be <= max (${max.css()})`,
                     details: { code: 'CALIPERS_E_CLAMP_INVALID_RANGE' },
                 });
@@ -299,7 +288,11 @@ export const createCoreApi = (errorStore) => {
             if (!guard(value)) {
                 throwHelperError({
                     operation: 'css-calipers.makeUnitAssert',
-                    params: isMeasurement(value) ? [value] : [],
+                    params: isMeasurement(value)
+                        ? [
+                            value,
+                        ]
+                        : [],
                     message: `Expected unit "${helper.unit}".`,
                     context,
                     details: { code: 'CALIPERS_E_ASSERT_UNIT' },
@@ -333,6 +326,74 @@ export const createCoreApi = (errorStore) => {
             });
         }
     };
+    // Value-constraint refinements. One factory builds the quartet (is / ensure / check /
+    // hardenWith) from a numeric predicate and narrows to a constraint brand. The brand is
+    // additive over `IMeasurement` and is dropped by arithmetic (which can cross a bound),
+    // so a derived result must be re-checked. `nonNegative` / `nonPositive` / `inRange(...)`
+    // are the built-ins.
+    const makeMeasurementRefinement = (spec) => {
+        const is = (measurement) => spec.predicate(measurement.getValue());
+        const ensure = (measurement, context) => {
+            if (!is(measurement)) {
+                throwHelperError({
+                    operation: 'css-calipers.refinement.ensure',
+                    params: [
+                        measurement,
+                    ],
+                    message: spec.message(measurement),
+                    context,
+                    details: { code: 'CALIPERS_E_CONSTRAINT' },
+                });
+            }
+            // A negated generic type-guard does not narrow the fall-through to `M & B`, so the
+            // brand cast is necessary here (the runtime check above guarantees it holds).
+            return measurement;
+        };
+        const check = (measurement) => is(measurement)
+            ? { ok: true, value: measurement }
+            : {
+                ok: false,
+                value: measurement,
+                error: spec.message(measurement),
+            };
+        const hardenWith = (measurement, fallback) => {
+            if (is(measurement))
+                return measurement;
+            if (fallback !== undefined)
+                return fallback;
+            const { defaultFallback } = spec;
+            if (defaultFallback !== undefined) {
+                return createMeasurement(defaultFallback, measurement.getUnit());
+            }
+            return throwHelperError({
+                operation: 'css-calipers.refinement.hardenWith',
+                params: [
+                    measurement,
+                ],
+                message: 'no fallback provided and this refinement has no default fallback',
+                details: { code: 'CALIPERS_E_CONSTRAINT' },
+            });
+        };
+        return { is, ensure, check, hardenWith };
+    };
+    const nonNegative = makeMeasurementRefinement({
+        predicate: (value) => value >= 0,
+        message: (measurement) => `expected a measurement >= 0 (got ${measurement.css()})`,
+        defaultFallback: 0,
+    });
+    const nonPositive = makeMeasurementRefinement({
+        predicate: (value) => value <= 0,
+        message: (measurement) => `expected a measurement <= 0 (got ${measurement.css()})`,
+        defaultFallback: 0,
+    });
+    const inRange = (min, max) => {
+        assertCondition(min <= max, `inRange: min (${min}) must be <= max (${max})`);
+        return makeMeasurementRefinement({
+            predicate: (value) => value >= min && value <= max,
+            message: (measurement) => `expected a measurement in [${min}, ${max}] (got ${measurement.css()})`,
+            defaultFallback: min,
+        });
+    };
     return {
         m,
         isMeasurement,
@@ -347,6 +408,10 @@ export const createCoreApi = (errorStore) => {
         hasCssMethod,
         assertUnit,
         assertCondition,
+        makeMeasurementRefinement,
+        nonNegative,
+        nonPositive,
+        inRange,
         getErrorConfig: errorStore.getErrorConfig,
         setErrorConfig: errorStore.setErrorConfig,
     };

package/dist/esm/internal/createUnitsApi.d.ts

@@ -1,4 +1,4 @@
-import type { UnitHelper, UnitGuard, UnitAssertion } from '../core';
+import type { UnitAssertion, UnitGuard, UnitHelper } from '../core';
 import type { UnitDefinitionRecord, UnitHelperName } from '../unitDefinitions';
 import type { CoreApi } from './createCoreApi';
 type UnitHelpersMap = {

package/dist/esm/internal/createUnitsApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createUnitsApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createUnitsApi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,KAAK,cAAc,GAAG;KACnB,CAAC,IAAI,cAAc,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CACnE,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG;IACtC,oBAAoB,EAAE,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC5D,wBAAwB,EAAE,aAAa,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;CACrE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,OAAO,KAAG,QAmB9C,CAAC"}
+{"version":3,"file":"createUnitsApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createUnitsApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,KAAK,cAAc,GAAG;KACnB,CAAC,IAAI,cAAc,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;CACnE,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG;IACtC,oBAAoB,EAAE,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC5D,wBAAwB,EAAE,aAAa,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;CACrE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,OAAO,KAAG,QAiB9C,CAAC"}

package/dist/esm/internal/errors.d.ts

@@ -1,12 +1,12 @@
-import type { IMeasurement } from "../core";
-export type ErrorCode = "CALIPERS_E_NONFINITE" | "CALIPERS_E_UNIT_MISMATCH" | "CALIPERS_E_ASSERT_UNIT" | "CALIPERS_E_ASSERT_CONDITION" | "CALIPERS_E_ASSERT_PREDICATE" | "CALIPERS_E_DIVIDE_BY_ZERO" | "CALIPERS_E_NONFINITE_RESULT" | "CALIPERS_E_CLAMP_NONFINITE_BOUNDS" | "CALIPERS_E_CLAMP_INVALID_RANGE";
+import type { IMeasurement } from '../core';
+export type ErrorCode = 'CALIPERS_E_NONFINITE' | 'CALIPERS_E_UNIT_MISMATCH' | 'CALIPERS_E_ASSERT_UNIT' | 'CALIPERS_E_ASSERT_CONDITION' | 'CALIPERS_E_ASSERT_PREDICATE' | 'CALIPERS_E_CONSTRAINT' | 'CALIPERS_E_DIVIDE_BY_ZERO' | 'CALIPERS_E_NONFINITE_RESULT' | 'CALIPERS_E_CLAMP_NONFINITE_BOUNDS' | 'CALIPERS_E_CLAMP_INVALID_RANGE';
 export interface ErrorDetails {
     code?: ErrorCode;
     helper?: string;
     inputSummary?: string;
     stackHint?: string;
 }
-export type StackHintMode = "auto" | "on" | "off";
+export type StackHintMode = 'auto' | 'on' | 'off';
 export interface ErrorConfig {
     stackHints?: StackHintMode;
 }

package/dist/esm/internal/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,MAAM,SAAS,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,wBAAwB,GACxB,6BAA6B,GAC7B,6BAA6B,GAC7B,2BAA2B,GAC3B,6BAA6B,GAC7B,mCAAmC,GACnC,gCAAgC,CAAC;AAErC,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,EAAE,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC5C,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7B,kEAAkE;IAClE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAQD,eAAO,MAAM,sBAAsB,GACjC,UAAS,WAAgB,KACxB,gBAWF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,WAAW,KAAG,IAElD,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,QAAQ,CAAC,WAAW,CAAgB,CAAC;AAEvE,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB;uCAIjD,6BAA6B,KACjC,KAAK;4BAeuB,kBAAkB,KAAG,KAAK;CAgB1D,CAAC;AA4DF,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,GACtC,KAAK,6BAA6B,KACjC,KAWF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,KAAK,kBAAkB,KAAG,KAW1D,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,MAAM,SAAS,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,wBAAwB,GACxB,6BAA6B,GAC7B,6BAA6B,GAC7B,uBAAuB,GACvB,2BAA2B,GAC3B,6BAA6B,GAC7B,mCAAmC,GACnC,gCAAgC,CAAC;AAErC,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,EAAE,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC5C,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7B,kEAAkE;IAClE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAQD,eAAO,MAAM,sBAAsB,GACjC,UAAS,WAAgB,KACxB,gBAWF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,WAAW,KAAG,IAElD,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,QAAQ,CAAC,WAAW,CACzC,CAAC;AAEd,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB;uCAIjD,6BAA6B,KACjC,KAAK;4BAeuB,kBAAkB,KAAG,KAAK;CAgB1D,CAAC;AA6DF,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,GACtC,KAAK,6BAA6B,KACjC,KAWF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,KAAK,kBAAkB,KAAG,KAW1D,CAAC"}

package/dist/esm/internal/errors.js

@@ -1,5 +1,5 @@
 const DEFAULT_ERROR_CONFIG = {
-    stackHints: "auto",
+    stackHints: 'auto',
 };
 let errorConfig = { ...DEFAULT_ERROR_CONFIG };
 export const createErrorConfigStore = (initial = {}) => {
@@ -44,18 +44,17 @@ export const createErrorHelpers = (store) => {
 };
 const isProductionEnv = () => {
     var _a;
-    if (typeof globalThis === "undefined")
+    if (typeof globalThis === 'undefined')
         return false;
-    const maybeProcess = globalThis
-        .process;
-    return ((_a = maybeProcess === null || maybeProcess === void 0 ? void 0 : maybeProcess.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) === "production";
+    const maybeProcess = globalThis.process;
+    return ((_a = maybeProcess === null || maybeProcess === void 0 ? void 0 : maybeProcess.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) === 'production';
 };
 const shouldIncludeStackHint = (override, config = errorConfig) => {
     if (override === false)
         return false;
-    if (config.stackHints === "off")
+    if (config.stackHints === 'off')
         return false;
-    if (config.stackHints === "on")
+    if (config.stackHints === 'on')
         return true;
     if (override === true)
         return !isProductionEnv();
@@ -63,7 +62,7 @@ const shouldIncludeStackHint = (override, config = errorConfig) => {
 };
 const formatDetailBlock = (details) => {
     if (!details)
-        return "";
+        return '';
     const parts = [];
     if (details.code)
         parts.push(`code=${details.code}`);
@@ -73,7 +72,7 @@ const formatDetailBlock = (details) => {
         parts.push(`inputs=${details.inputSummary}`);
     if (details.stackHint)
         parts.push(`stack=${details.stackHint}`);
-    return parts.length > 0 ? ` [${parts.join(" | ")}]` : "";
+    return parts.length > 0 ? ` [${parts.join(' | ')}]` : '';
 };
 const formatErrorMessage = (operation, message, context, details) => {
     const core = `${operation}: ${message}`;
@@ -85,17 +84,17 @@ const extractStackHint = (stack) => {
     if (!stack)
         return undefined;
     const lines = stack
-        .split("\n")
+        .split('\n')
         .map((line) => line.trim())
         .filter(Boolean)
         .slice(1);
     if (lines.length === 0)
         return undefined;
-    const filtered = lines.filter((line) => !line.includes("/src/internal/errors") &&
-        !line.includes("throwHelperError") &&
-        !line.includes("throwMeasurementMethodError"));
+    const filtered = lines.filter((line) => !line.includes('/src/internal/errors') &&
+        !line.includes('throwHelperError') &&
+        !line.includes('throwMeasurementMethodError'));
     const hint = (_a = filtered[0]) !== null && _a !== void 0 ? _a : lines[0];
-    return hint.replace(/^at\s+/, "");
+    return hint.replace(/^at\s+/, '');
 };
 /** Throw an Error for a Measurement instance method using a structured context. */
 export const throwMeasurementMethodError = (ctx) => {

package/dist/esm/internal/toPlainDecimal.d.ts

@@ -0,0 +1,2 @@
+export declare const toPlainDecimal: (value: number) => string;
+//# sourceMappingURL=toPlainDecimal.d.ts.map

package/dist/esm/internal/toPlainDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPlainDecimal.d.ts","sourceRoot":"","sources":["../../../src/internal/toPlainDecimal.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,MA2B9C,CAAC"}

package/dist/esm/internal/toPlainDecimal.js

@@ -0,0 +1,27 @@
+// JS stringifies numbers in exponential form once the magnitude is >= 1e21 or
+// < 1e-6 (e.g. "1e+21", "1e-7"). CSS output must never contain that, so we
+// expand the exponent into a plain decimal by shifting the decimal point on the
+// digit string. This is string manipulation on the same digits, so it does not
+// re-introduce floating-point error. Shared by the measurement core and the
+// scalar (float / integer) primitives so every `.css()` renders the same way.
+export const toPlainDecimal = (value) => {
+    const text = `${value}`;
+    if (!text.includes('e') && !text.includes('E')) {
+        return text;
+    }
+    const [mantissa, exponentText,] = text.toLowerCase().split('e');
+    const exponent = Number(exponentText);
+    const negative = mantissa.startsWith('-');
+    const unsigned = negative ? mantissa.slice(1) : mantissa;
+    const [intDigits, fracDigits = '',] = unsigned.split('.');
+    const digits = intDigits + fracDigits;
+    const pointFromLeft = intDigits.length + exponent;
+    const sign = negative ? '-' : '';
+    if (pointFromLeft <= 0) {
+        return `${sign}0.${'0'.repeat(-pointFromLeft)}${digits}`;
+    }
+    if (pointFromLeft >= digits.length) {
+        return `${sign}${digits}${'0'.repeat(pointFromLeft - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, pointFromLeft)}.${digits.slice(pointFromLeft)}`;
+};

package/dist/esm/measurements.d.ts

@@ -0,0 +1,16 @@
+export * from './core';
+export * from './default';
+export * from './units/absolute';
+export * from './units/angle';
+export * from './units/container';
+export * from './units/font-relative';
+export * from './units/frequency';
+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=measurements.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurements.d.ts","sourceRoot":"","sources":["../../src/measurements.ts"],"names":[],"mappings":"AAQA,cAAc,QAAQ,CAAC;AAGvB,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}