css-calipers 0.9.2 → 0.9.4

package/dist/esm/internal/createCoreApi.js

@@ -0,0 +1,332 @@
+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);
+};
+import { UNIT_DEFINITIONS, } from '../unitDefinitions';
+import { buildMeasurementCreationError } from './buildMeasurementCreationError';
+import { createErrorHelpers, } from './errors';
+export const createCoreApi = (errorStore) => {
+    var _Measurement_instances, _a, _Measurement_value, _Measurement_unit, _Measurement_clone;
+    const { throwHelperError, throwMeasurementMethodError } = createErrorHelpers(errorStore);
+    const assertMatchingUnits = (left, right, context) => {
+        const leftUnit = left.getUnit();
+        const rightUnit = right.getUnit();
+        if (leftUnit !== rightUnit) {
+            throwHelperError({
+                operation: 'css-calipers.assertMatchingUnits',
+                params: [left, right],
+                message: `measurement unit mismatch: ${leftUnit} vs ${rightUnit}`,
+                context,
+                details: { code: 'CALIPERS_E_UNIT_MISMATCH' },
+            });
+        }
+    };
+    const deltaToNumber = (base, delta) => {
+        if (typeof delta === 'number')
+            return delta;
+        assertMatchingUnits(base, delta, 'deltaToNumber');
+        return delta.getValue();
+    };
+    class Measurement {
+        constructor(value, unit) {
+            _Measurement_instances.add(this);
+            _Measurement_value.set(this, void 0);
+            _Measurement_unit.set(this, void 0);
+            if (!Number.isFinite(value)) {
+                throwHelperError({
+                    operation: 'css-calipers.Measurement.constructor',
+                    params: [],
+                    message: `Non-finite measurement value: ${value}`,
+                    details: { code: 'CALIPERS_E_NONFINITE' },
+                });
+            }
+            const normalizedUnit = unit.toLowerCase();
+            __classPrivateFieldSet(this, _Measurement_value, value, "f");
+            __classPrivateFieldSet(this, _Measurement_unit, normalizedUnit, "f");
+            Object.defineProperty(this, '__unitBrand', {
+                value: normalizedUnit,
+                enumerable: false,
+                configurable: false,
+                writable: false,
+            });
+        }
+        css() {
+            return `${__classPrivateFieldGet(this, _Measurement_value, "f")}${__classPrivateFieldGet(this, _Measurement_unit, "f")}`;
+        }
+        toString() {
+            return this.css();
+        }
+        getUnit() {
+            return __classPrivateFieldGet(this, _Measurement_unit, "f");
+        }
+        getValue() {
+            return __classPrivateFieldGet(this, _Measurement_value, "f");
+        }
+        valueOf() {
+            return __classPrivateFieldGet(this, _Measurement_value, "f");
+        }
+        [(_Measurement_value = new WeakMap(), _Measurement_unit = new WeakMap(), _Measurement_instances = new WeakSet(), Symbol.toPrimitive)](hint) {
+            if (hint === 'number')
+                return __classPrivateFieldGet(this, _Measurement_value, "f");
+            return this.css();
+        }
+        isUnit(expected) {
+            return __classPrivateFieldGet(this, _Measurement_unit, "f") === expected.toLowerCase();
+        }
+        assertUnit(expected, context) {
+            if (!this.isUnit(expected)) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.assertUnit',
+                    caller: this,
+                    params: [],
+                    message: `Expected unit "${expected}", received "${__classPrivateFieldGet(this, _Measurement_unit, "f")}".`,
+                    context,
+                    details: { code: 'CALIPERS_E_ASSERT_UNIT' },
+                });
+            }
+        }
+        assert(predicate, message) {
+            if (!predicate(this)) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.assert',
+                    caller: this,
+                    params: [],
+                    message,
+                    details: { code: 'CALIPERS_E_ASSERT_PREDICATE' },
+                });
+            }
+        }
+        equals(other, strict = true) {
+            const otherUnit = other.getUnit();
+            if (__classPrivateFieldGet(this, _Measurement_unit, "f") !== otherUnit) {
+                if (strict) {
+                    assertMatchingUnits(this, other, 'equals(strict)');
+                }
+                return false;
+            }
+            return __classPrivateFieldGet(this, _Measurement_value, "f") === other.getValue();
+        }
+        compare(other, strict = true) {
+            if (strict) {
+                assertMatchingUnits(this, other, 'compare(strict)');
+            }
+            else if (__classPrivateFieldGet(this, _Measurement_unit, "f") !== other.getUnit()) {
+                return __classPrivateFieldGet(this, _Measurement_unit, "f") < other.getUnit() ? -1 : 1;
+            }
+            const diff = __classPrivateFieldGet(this, _Measurement_value, "f") - other.getValue();
+            if (diff === 0)
+                return 0;
+            return diff < 0 ? -1 : 1;
+        }
+        add(delta) {
+            const next = __classPrivateFieldGet(this, _Measurement_value, "f") + deltaToNumber(this, delta);
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
+        }
+        subtract(delta) {
+            const next = __classPrivateFieldGet(this, _Measurement_value, "f") - deltaToNumber(this, delta);
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
+        }
+        multiply(factor) {
+            if (factor === 1)
+                return this;
+            if (factor === 0)
+                return new _a(0, __classPrivateFieldGet(this, _Measurement_unit, "f"));
+            if (factor === -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);
+        }
+        divide(divisor) {
+            if (divisor === 1)
+                return this;
+            if (divisor === 0) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.divide',
+                    caller: this,
+                    params: [],
+                    message: `Cannot divide ${this.css()} by zero`,
+                    details: { code: 'CALIPERS_E_DIVIDE_BY_ZERO' },
+                });
+            }
+            const result = __classPrivateFieldGet(this, _Measurement_value, "f") / divisor;
+            if (!Number.isFinite(result)) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.divide',
+                    caller: this,
+                    params: [],
+                    message: 'Non-finite result',
+                    details: { code: 'CALIPERS_E_NONFINITE_RESULT' },
+                });
+            }
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, result);
+        }
+        double() {
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") * 2);
+        }
+        half() {
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, __classPrivateFieldGet(this, _Measurement_value, "f") / 2);
+        }
+        negation(shouldNegate = true) {
+            return shouldNegate ? __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, -__classPrivateFieldGet(this, _Measurement_value, "f")) : this;
+        }
+        absolute() {
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.abs(__classPrivateFieldGet(this, _Measurement_value, "f")));
+        }
+        round(precision = 0) {
+            const next = precision === 0
+                ? Math.round(__classPrivateFieldGet(this, _Measurement_value, "f"))
+                : Number(__classPrivateFieldGet(this, _Measurement_value, "f").toFixed(precision));
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, next);
+        }
+        floor() {
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.floor(__classPrivateFieldGet(this, _Measurement_value, "f")));
+        }
+        ceil() {
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, Math.ceil(__classPrivateFieldGet(this, _Measurement_value, "f")));
+        }
+        clamp(min, max) {
+            assertMatchingUnits(this, min, 'clamp(min)');
+            assertMatchingUnits(this, max, 'clamp(max)');
+            const minValue = min.getValue();
+            const maxValue = max.getValue();
+            if (!Number.isFinite(minValue) || !Number.isFinite(maxValue)) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.clamp',
+                    caller: this,
+                    params: [min, max],
+                    message: 'clamp: expected finite bounds',
+                    details: { code: 'CALIPERS_E_CLAMP_NONFINITE_BOUNDS' },
+                });
+            }
+            if (minValue > maxValue) {
+                throwMeasurementMethodError({
+                    operation: 'css-calipers.Measurement.clamp',
+                    caller: this,
+                    params: [min, max],
+                    message: `clamp: min (${min.css()}) must be <= max (${max.css()})`,
+                    details: { code: 'CALIPERS_E_CLAMP_INVALID_RANGE' },
+                });
+            }
+            const clamped = Math.min(maxValue, Math.max(minValue, __classPrivateFieldGet(this, _Measurement_value, "f")));
+            return __classPrivateFieldGet(this, _Measurement_instances, "m", _Measurement_clone).call(this, clamped);
+        }
+    }
+    _a = Measurement, _Measurement_clone = function _Measurement_clone(value) {
+        return new _a(value, __classPrivateFieldGet(this, _Measurement_unit, "f"));
+    };
+    const createMeasurement = (value, unit) => new Measurement(value, unit);
+    const isMeasurement = (x) => x instanceof Measurement;
+    function m(value, unitOrOptions = 'px', context) {
+        var _b;
+        const options = unitOrOptions && typeof unitOrOptions === 'object'
+            ? unitOrOptions
+            : { unit: unitOrOptions, context };
+        const unit = ((_b = options.unit) !== null && _b !== void 0 ? _b : 'px');
+        const contextLabel = options.context;
+        const normalizedUnit = unit.toLowerCase();
+        if (!Number.isFinite(value)) {
+            const errorPayload = buildMeasurementCreationError(value, normalizedUnit, 'm', contextLabel);
+            throwHelperError({
+                operation: 'css-calipers.m',
+                params: [],
+                message: errorPayload.message,
+                context: errorPayload.context,
+                details: errorPayload.details,
+                includeStackHint: true,
+            });
+        }
+        return createMeasurement(value, normalizedUnit);
+    }
+    const createUnitHelper = (unit, helperName) => {
+        const normalizedUnit = unit.toLowerCase();
+        const helperLabel = helperName !== null && helperName !== void 0 ? helperName : `makeUnitHelper(${normalizedUnit})`;
+        const factory = (value, context) => {
+            if (!Number.isFinite(value)) {
+                const errorPayload = buildMeasurementCreationError(value, normalizedUnit, helperLabel, context);
+                throwHelperError({
+                    operation: `css-calipers.${helperLabel}`,
+                    params: [],
+                    message: errorPayload.message,
+                    context: errorPayload.context,
+                    details: errorPayload.details,
+                    includeStackHint: true,
+                });
+            }
+            return createMeasurement(value, normalizedUnit);
+        };
+        return Object.assign(factory, {
+            unit: normalizedUnit,
+        });
+    };
+    const makeUnitHelper = (unit) => {
+        return createUnitHelper(unit);
+    };
+    const makeUnitHelperFromDefinition = (name) => createUnitHelper(UNIT_DEFINITIONS[name].unit, name);
+    const measurementUnitMetadata = UNIT_DEFINITIONS;
+    const makeUnitGuard = (helper) => {
+        return (value) => isMeasurement(value) && value.isUnit(helper.unit);
+    };
+    const makeUnitAssert = (helper) => {
+        const guard = makeUnitGuard(helper);
+        return (value, context) => {
+            if (!guard(value)) {
+                throwHelperError({
+                    operation: 'css-calipers.makeUnitAssert',
+                    params: isMeasurement(value) ? [value] : [],
+                    message: `Expected unit "${helper.unit}".`,
+                    context,
+                    details: { code: 'CALIPERS_E_ASSERT_UNIT' },
+                });
+            }
+        };
+    };
+    const hasCssMethod = (x) => {
+        return (typeof x === 'object' &&
+            x !== null &&
+            'css' in x &&
+            typeof x.css === 'function');
+    };
+    const measurementMin = (a, b) => {
+        assertMatchingUnits(a, b, 'measurementMin');
+        return a.getValue() <= b.getValue() ? a : b;
+    };
+    const measurementMax = (a, b) => {
+        assertMatchingUnits(a, b, 'measurementMax');
+        return a.getValue() >= b.getValue() ? a : b;
+    };
+    const assertUnit = (measurement, expectedUnit, context) => measurement.assertUnit(expectedUnit, context);
+    const assertCondition = (condition, message) => {
+        const passed = typeof condition === 'function' ? condition() : condition;
+        if (!passed) {
+            throwHelperError({
+                operation: 'css-calipers.assertCondition',
+                params: [],
+                message,
+                details: { code: 'CALIPERS_E_ASSERT_CONDITION' },
+            });
+        }
+    };
+    return {
+        m,
+        isMeasurement,
+        assertMatchingUnits,
+        measurementMin,
+        measurementMax,
+        measurementUnitMetadata,
+        makeUnitHelper,
+        makeUnitHelperFromDefinition,
+        makeUnitGuard,
+        makeUnitAssert,
+        hasCssMethod,
+        assertUnit,
+        assertCondition,
+        getErrorConfig: errorStore.getErrorConfig,
+        setErrorConfig: errorStore.setErrorConfig,
+    };
+};

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

@@ -0,0 +1,35 @@
+import type { CoreApi } from './createCoreApi';
+import type { ComplexStyleRule, StyleRule } from '../mediaQueries/types';
+import { type IMediaQueries, type IMediaQueryProps, type IMediaQueryStyles } from '../mediaQueries/mediaQueries';
+import { type IMediaQueryCustomFeatures, type IMediaQueryDimensions, type IMediaQueryDisplay, type IMediaQueryEnvironment, type IMediaQueryInteraction, type IMediaQueryPreferences } from '../mediaQueries/modules';
+import { type IMediaQueryResolutionRange } from '../mediaQueries/modules/resolution';
+import { type MediaQueryFactoryConfig } from '../mediaQueries/factory';
+import type { MediaQueryBuilderHelpers } from '../mediaQueries/helpers';
+import type { MediaQueryModulesList } from '../mediaQueries/moduleRegistry';
+type MediaQueriesCore = Pick<CoreApi, 'assertCondition' | 'assertMatchingUnits'>;
+export declare const createMediaQueriesApi: (core: MediaQueriesCore) => {
+    readonly buildMediaQueryString: (config: IMediaQueryProps) => string;
+    readonly makeMediaQueryStyle: <T extends IMediaQueries>(queries: T) => (stylesByQuery: IMediaQueryStyles<T>) => ComplexStyleRule;
+    readonly mediaQueryFactory: <TModules extends MediaQueryModulesList | undefined, TQueries extends Record<string, TModules extends MediaQueryModulesList ? (import("../mediaQueries/moduleRegistry").MediaQueryModulePropsMap[TModules[number]] extends infer T ? T extends import("../mediaQueries/moduleRegistry").MediaQueryModulePropsMap[TModules[number]] ? T extends unknown ? (value: T) => void : never : never : never) extends (value: infer R) => void ? R : never : IMediaQueryProps>, TOutput = ComplexStyleRule>(options: {
+        queries: TQueries;
+        config: MediaQueryFactoryConfig<TModules, TOutput>;
+    }) => (stylesByQuery: Partial<Record<keyof TQueries, StyleRule>>) => TOutput;
+    readonly emitCoreFeatures: (props: import("../mediaQueries/mediaQueries").IMediaQueryCore, helpers: MediaQueryBuilderHelpers) => void;
+    readonly emitDimensionsFeatures: (props: IMediaQueryDimensions, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryDimensionsValidator) => void;
+    readonly emitResolutionFeatures: (props: IMediaQueryResolutionRange, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryResolutionValidator) => void;
+    readonly emitInteractionFeatures: (props: IMediaQueryInteraction, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryInteractionValidator) => void;
+    readonly emitPreferencesFeatures: (props: IMediaQueryPreferences, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryPreferencesValidator) => void;
+    readonly emitDisplayFeatures: (props: IMediaQueryDisplay, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryDisplayValidator) => void;
+    readonly emitEnvironmentFeatures: (props: IMediaQueryEnvironment, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryEnvironmentValidator) => void;
+    readonly emitCustomFeatures: (props: IMediaQueryCustomFeatures, helpers: MediaQueryBuilderHelpers, validate?: import("../mediaQueries/modules").MediaQueryCustomFeaturesValidator) => void;
+    readonly mediaQueryOutputVanillaExtract: (media: StyleRule) => import("../mediaQueries/types").SelectorMap;
+    readonly createMediaQueryBuilder: <TConfig>(options: {
+        emitBase: import("../mediaQueries/helpers").MediaQueryExtensionHandler<TConfig>;
+        emitExtensions?: import("../mediaQueries/helpers").MediaQueryExtensionHandler<TConfig> | undefined;
+        resolveType?: ((config: TConfig) => "all" | "print" | "screen" | undefined) | undefined;
+        config?: import("../mediaQueries/helpers").MediaQueryBuilderConfig;
+    }) => (config: TConfig) => string;
+};
+export type MediaQueriesApi = ReturnType<typeof createMediaQueriesApi>;
+export type { IMediaQueries, IMediaQueryProps, IMediaQueryStyles, IMediaQueryCustomFeatures, IMediaQueryDimensions, IMediaQueryResolutionRange, IMediaQueryInteraction, IMediaQueryPreferences, IMediaQueryDisplay, IMediaQueryEnvironment, MediaQueryFactoryConfig, MediaQueryModulesList, };
+//# sourceMappingURL=createMediaQueriesApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createMediaQueriesApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createMediaQueriesApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAIzE,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAOL,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAE5E,KAAK,gBAAgB,GAAG,IAAI,CAC1B,OAAO,EACP,iBAAiB,GAAG,qBAAqB,CAC1C,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,MAAM,gBAAgB;;mCAkCvD,CAAC,SAAS,aAAa,WAAW,CAAC,MACnC,eAAe,iBAAiB,CAAC,CAAC,CAAC,KAAG,gBAAgB;;;;WA+DiuF,yDAA2C;;;;;;;;;;;;;;;WA1D7zF,eAAO;CAyChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACvE,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,GACtB,CAAC"}

package/dist/esm/internal/createMediaQueriesApi.js

@@ -0,0 +1,70 @@
+import { createMediaQueryBuilder } from '../mediaQueries/helpers';
+import { createMediaQueryValidation, } from '../mediaQueries/validation';
+import { createEmitCoreFeatures, } from '../mediaQueries/mediaQueries';
+import { createEmitDimensionsFeatures, emitDisplayFeatures, emitEnvironmentFeatures, emitInteractionFeatures, emitPreferencesFeatures, emitCustomFeatures, } from '../mediaQueries/modules';
+import { createEmitResolutionFeatures, } from '../mediaQueries/modules/resolution';
+import { createMediaQueryFactory, } from '../mediaQueries/factory';
+import { mediaQueryOutputVanillaExtract } from '../mediaQueries/libraryHelpers/vanilla-extract';
+export const createMediaQueriesApi = (core) => {
+    const validation = createMediaQueryValidation({
+        assertCondition: core.assertCondition,
+        assertMatchingUnits: core.assertMatchingUnits,
+    });
+    const emitCoreFeatures = createEmitCoreFeatures(validation);
+    const emitDimensionsFeatures = createEmitDimensionsFeatures(validation);
+    const emitResolutionFeatures = createEmitResolutionFeatures(validation);
+    const emitBaseFeatures = (props, helpers) => {
+        emitCoreFeatures(props, helpers);
+        emitDimensionsFeatures(props, helpers);
+        emitResolutionFeatures(props, helpers);
+        emitInteractionFeatures(props, helpers);
+        emitPreferencesFeatures(props, helpers);
+        emitDisplayFeatures(props, helpers);
+        emitEnvironmentFeatures(props, helpers);
+        emitCustomFeatures(props, helpers);
+    };
+    const buildMediaQueryString = createMediaQueryBuilder({
+        emitBase: emitBaseFeatures,
+        resolveType: (props) => props.type,
+    });
+    const makeMediaQueryStyle = (queries) => (stylesByQuery) => {
+        const result = {};
+        Object.keys(stylesByQuery).forEach((key) => {
+            const styles = stylesByQuery[key];
+            const props = queries[key];
+            if (!styles || !props)
+                return;
+            result[buildMediaQueryString(props)] = styles;
+        });
+        const mediaQuery = {
+            '@media': result,
+        };
+        return mediaQuery;
+    };
+    const moduleEmitters = {
+        core: emitCoreFeatures,
+        dimensions: emitDimensionsFeatures,
+        resolution: emitResolutionFeatures,
+        interaction: emitInteractionFeatures,
+        preferences: emitPreferencesFeatures,
+        display: emitDisplayFeatures,
+        environment: emitEnvironmentFeatures,
+        custom: emitCustomFeatures,
+    };
+    const mediaQueryFactory = createMediaQueryFactory(moduleEmitters);
+    return {
+        buildMediaQueryString,
+        makeMediaQueryStyle,
+        mediaQueryFactory,
+        emitCoreFeatures,
+        emitDimensionsFeatures,
+        emitResolutionFeatures,
+        emitInteractionFeatures,
+        emitPreferencesFeatures,
+        emitDisplayFeatures,
+        emitEnvironmentFeatures,
+        emitCustomFeatures,
+        mediaQueryOutputVanillaExtract,
+        createMediaQueryBuilder,
+    };
+};

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

@@ -0,0 +1,13 @@
+import type { UnitHelper, UnitGuard, UnitAssertion } from '../core';
+import type { UnitDefinitionRecord, UnitHelperName } from '../unitDefinitions';
+import type { CoreApi } from './createCoreApi';
+type UnitHelpersMap = {
+    [K in UnitHelperName]: UnitHelper<UnitDefinitionRecord[K]['unit']>;
+};
+export type UnitsApi = UnitHelpersMap & {
+    isPercentMeasurement: UnitGuard<UnitHelpersMap['mPercent']>;
+    assertPercentMeasurement: UnitAssertion<UnitHelpersMap['mPercent']>;
+};
+export declare const createUnitsApi: (core: CoreApi) => UnitsApi;
+export {};
+//# sourceMappingURL=createUnitsApi.d.ts.map

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

@@ -0,0 +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"}

package/dist/esm/internal/createUnitsApi.js

@@ -0,0 +1,14 @@
+import { UNIT_DEFINITIONS } from '../unitDefinitions';
+export const createUnitsApi = (core) => {
+    const helpers = Object.keys(UNIT_DEFINITIONS).reduce((acc, name) => {
+        const helperName = name;
+        acc[helperName] = core.makeUnitHelperFromDefinition(helperName);
+        return acc;
+    }, {});
+    const mPercent = helpers.mPercent;
+    return {
+        ...helpers,
+        isPercentMeasurement: core.makeUnitGuard(mPercent),
+        assertPercentMeasurement: core.makeUnitAssert(mPercent),
+    };
+};

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

@@ -1,4 +1,19 @@
 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";
+export interface ErrorDetails {
+    code?: ErrorCode;
+    helper?: string;
+    inputSummary?: string;
+    stackHint?: string;
+}
+export type StackHintMode = "auto" | "on" | "off";
+export interface ErrorConfig {
+    stackHints?: StackHintMode;
+}
+export type ErrorConfigStore = {
+    getErrorConfig: () => Required<ErrorConfig>;
+    setErrorConfig: (next: ErrorConfig) => void;
+};
 export interface MeasurementMethodErrorContext {
     /** Operation name (for example, "add", "divide", "clamp"). */
     operation: string;
@@ -10,6 +25,10 @@ export interface MeasurementMethodErrorContext {
     message: string;
     /** Optional caller-supplied context prefix. */
     context?: string;
+    /** Optional extra details for error formatting. */
+    details?: ErrorDetails;
+    /** Override the stack hint config for this error. */
+    includeStackHint?: boolean;
 }
 export interface HelperErrorContext {
     /** Operation name (for example, "assertMatchingUnits"). */
@@ -20,7 +39,18 @@ export interface HelperErrorContext {
     message: string;
     /** Optional caller-supplied context prefix. */
     context?: string;
+    /** Optional extra details for error formatting. */
+    details?: ErrorDetails;
+    /** Override the stack hint config for this error. */
+    includeStackHint?: boolean;
 }
+export declare const createErrorConfigStore: (initial?: ErrorConfig) => ErrorConfigStore;
+export declare const setErrorConfig: (next: ErrorConfig) => void;
+export declare const getErrorConfig: () => Required<ErrorConfig>;
+export declare const createErrorHelpers: (store: ErrorConfigStore) => {
+    throwMeasurementMethodError: (ctx: MeasurementMethodErrorContext) => never;
+    throwHelperError: (ctx: HelperErrorContext) => never;
+};
 /** Throw an Error for a Measurement instance method using a structured context. */
 export declare const throwMeasurementMethodError: (ctx: MeasurementMethodErrorContext) => never;
 /** Throw an Error for a helper/free function using a structured context. */

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,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;CAClB;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;CAClB;AAWD,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,GACtC,KAAK,6BAA6B,KACjC,KAIF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,KAAK,kBAAkB,KAAG,KAI1D,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,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"}

package/dist/esm/internal/errors.js

@@ -1,12 +1,121 @@
-const formatErrorMessage = (operation, message, context) => {
+const DEFAULT_ERROR_CONFIG = {
+    stackHints: "auto",
+};
+let errorConfig = { ...DEFAULT_ERROR_CONFIG };
+export const createErrorConfigStore = (initial = {}) => {
+    let config = {
+        ...DEFAULT_ERROR_CONFIG,
+        ...initial,
+    };
+    return {
+        getErrorConfig: () => config,
+        setErrorConfig: (next) => {
+            config = { ...config, ...next };
+        },
+    };
+};
+export const setErrorConfig = (next) => {
+    errorConfig = { ...errorConfig, ...next };
+};
+export const getErrorConfig = () => errorConfig;
+export const createErrorHelpers = (store) => {
+    const getConfig = () => store.getErrorConfig();
+    const throwMeasurementMethodError = (ctx) => {
+        const includeStack = shouldIncludeStackHint(ctx.includeStackHint, getConfig());
+        const stackHint = includeStack
+            ? extractStackHint(new Error().stack)
+            : undefined;
+        throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+            ...ctx.details,
+            stackHint,
+        }));
+    };
+    const throwHelperError = (ctx) => {
+        const includeStack = shouldIncludeStackHint(ctx.includeStackHint, getConfig());
+        const stackHint = includeStack
+            ? extractStackHint(new Error().stack)
+            : undefined;
+        throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+            ...ctx.details,
+            stackHint,
+        }));
+    };
+    return { throwMeasurementMethodError, throwHelperError };
+};
+const isProductionEnv = () => {
+    var _a;
+    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 shouldIncludeStackHint = (override, config = errorConfig) => {
+    if (override === false)
+        return false;
+    if (config.stackHints === "off")
+        return false;
+    if (config.stackHints === "on")
+        return true;
+    if (override === true)
+        return !isProductionEnv();
+    return false;
+};
+const formatDetailBlock = (details) => {
+    if (!details)
+        return "";
+    const parts = [];
+    if (details.code)
+        parts.push(`code=${details.code}`);
+    if (details.helper)
+        parts.push(`helper=${details.helper}`);
+    if (details.inputSummary)
+        parts.push(`inputs=${details.inputSummary}`);
+    if (details.stackHint)
+        parts.push(`stack=${details.stackHint}`);
+    return parts.length > 0 ? ` [${parts.join(" | ")}]` : "";
+};
+const formatErrorMessage = (operation, message, context, details) => {
     const core = `${operation}: ${message}`;
-    return context ? `${context}: ${core}` : core;
+    const base = context ? `${context}: ${core}` : core;
+    return `${base}${formatDetailBlock(details)}`;
+};
+const extractStackHint = (stack) => {
+    var _a;
+    if (!stack)
+        return undefined;
+    const lines = stack
+        .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 hint = (_a = filtered[0]) !== null && _a !== void 0 ? _a : lines[0];
+    return hint.replace(/^at\s+/, "");
 };
 /** Throw an Error for a Measurement instance method using a structured context. */
 export const throwMeasurementMethodError = (ctx) => {
-    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context));
+    const includeStack = shouldIncludeStackHint(ctx.includeStackHint);
+    const stackHint = includeStack
+        ? extractStackHint(new Error().stack)
+        : undefined;
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+        ...ctx.details,
+        stackHint,
+    }));
 };
 /** Throw an Error for a helper/free function using a structured context. */
 export const throwHelperError = (ctx) => {
-    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context));
+    const includeStack = shouldIncludeStackHint(ctx.includeStackHint);
+    const stackHint = includeStack
+        ? extractStackHint(new Error().stack)
+        : undefined;
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context, {
+        ...ctx.details,
+        stackHint,
+    }));
 };