css-calipers 0.9.3 → 0.9.4

package/dist/examples/src/containerQueries/validation.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultContainerQueryValidation = exports.validateCustomFeatures = exports.validateStyleValues = exports.validateAspectRatioValues = exports.validateBlockSizeValues = exports.validateInlineSizeValues = exports.validateHeightValuesPositive = exports.validateMinMaxHeight = exports.validateWidthValuesPositive = exports.validateMinMaxWidth = exports.runContainerQueryValidation = exports.createContainerQueryValidation = void 0;
+const helpers_1 = require("./helpers");
+const core_1 = require("../core");
+const validation_1 = require("../validation");
+const ratio_1 = require("../ratio");
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const assertMeasurement = (value, label) => {
+    (0, core_1.assertCondition)((0, core_1.isMeasurement)(value), `${label} must be a measurement`);
+};
+const assertMeasurementPositive = (value, label) => {
+    (0, core_1.assertCondition)(value.getValue() > 0, `${label} must be greater than 0`);
+};
+const assertRatio = (value, label) => {
+    (0, core_1.assertCondition)((0, core_1.isRatio)(value), `${label} must be a ratio created with r()`);
+};
+const assertRatioPositive = (value, label) => {
+    (0, core_1.assertCondition)(value.numerator() > 0, `${label} numerator must be greater than 0`);
+    (0, core_1.assertCondition)(value.denominator() > 0, `${label} denominator must be greater than 0`);
+};
+const isStyleValue = (value) => {
+    if (typeof value === "string")
+        return true;
+    if (isFiniteNumber(value))
+        return true;
+    if ((0, core_1.hasCssMethod)(value))
+        return true;
+    return false;
+};
+const createContainerQueryValidation = (core) => {
+    const assertCondition = core.assertCondition;
+    const assertMatchingUnits = core.assertMatchingUnits;
+    const runContainerQueryValidation = (config, helpers, check, context, fallbackMessage = "Invalid container query configuration") => {
+        if (!check)
+            return true;
+        try {
+            check(config);
+            return true;
+        }
+        catch (error) {
+            const result = (0, validation_1.toValidationResult)(error, fallbackMessage);
+            return (0, helpers_1.applyContainerQueryValidation)(config, helpers, () => result, context);
+        }
+    };
+    const validateMinMaxWidth = (props) => {
+        if (!props.minWidth || !props.maxWidth)
+            return;
+        assertMatchingUnits(props.minWidth, props.maxWidth, "containerQueries.minMaxWidth");
+        assertCondition(props.minWidth.getValue() <= props.maxWidth.getValue(), "minWidth must be less than or equal to maxWidth");
+    };
+    const validateWidthValuesPositive = (props) => {
+        if (props.minWidth) {
+            assertMeasurement(props.minWidth, "minWidth");
+            assertMeasurementPositive(props.minWidth, "minWidth");
+        }
+        if (props.maxWidth) {
+            assertMeasurement(props.maxWidth, "maxWidth");
+            assertMeasurementPositive(props.maxWidth, "maxWidth");
+        }
+    };
+    const validateMinMaxHeight = (props) => {
+        if (!props.minHeight || !props.maxHeight)
+            return;
+        assertMatchingUnits(props.minHeight, props.maxHeight, "containerQueries.minMaxHeight");
+        assertCondition(props.minHeight.getValue() <= props.maxHeight.getValue(), "minHeight must be less than or equal to maxHeight");
+    };
+    const validateHeightValuesPositive = (props) => {
+        if (props.minHeight) {
+            assertMeasurement(props.minHeight, "minHeight");
+            assertMeasurementPositive(props.minHeight, "minHeight");
+        }
+        if (props.maxHeight) {
+            assertMeasurement(props.maxHeight, "maxHeight");
+            assertMeasurementPositive(props.maxHeight, "maxHeight");
+        }
+    };
+    const validateInlineSizeValues = (props) => {
+        if (props.inlineSize) {
+            assertMeasurement(props.inlineSize.value, "inlineSize");
+            assertMeasurementPositive(props.inlineSize.value, "inlineSize");
+        }
+        if (props.inlineSizeRange) {
+            assertMeasurement(props.inlineSizeRange.min, "inlineSizeRange.min");
+            assertMeasurement(props.inlineSizeRange.max, "inlineSizeRange.max");
+            assertMeasurementPositive(props.inlineSizeRange.min, "inlineSizeRange.min");
+            assertMeasurementPositive(props.inlineSizeRange.max, "inlineSizeRange.max");
+            assertMatchingUnits(props.inlineSizeRange.min, props.inlineSizeRange.max, "containerQueries.inlineSizeRangeUnits");
+            assertCondition(props.inlineSizeRange.min.getValue() <=
+                props.inlineSizeRange.max.getValue(), "inlineSizeRange min must be less than or equal to max");
+        }
+    };
+    const validateBlockSizeValues = (props) => {
+        if (props.blockSize) {
+            assertMeasurement(props.blockSize.value, "blockSize");
+            assertMeasurementPositive(props.blockSize.value, "blockSize");
+        }
+        if (props.blockSizeRange) {
+            assertMeasurement(props.blockSizeRange.min, "blockSizeRange.min");
+            assertMeasurement(props.blockSizeRange.max, "blockSizeRange.max");
+            assertMeasurementPositive(props.blockSizeRange.min, "blockSizeRange.min");
+            assertMeasurementPositive(props.blockSizeRange.max, "blockSizeRange.max");
+            assertMatchingUnits(props.blockSizeRange.min, props.blockSizeRange.max, "containerQueries.blockSizeRangeUnits");
+            assertCondition(props.blockSizeRange.min.getValue() <=
+                props.blockSizeRange.max.getValue(), "blockSizeRange min must be less than or equal to max");
+        }
+    };
+    const validateAspectRatioValues = (props) => {
+        if (props.aspectRatio) {
+            assertRatio(props.aspectRatio, "aspectRatio");
+            assertRatioPositive(props.aspectRatio, "aspectRatio");
+        }
+        if (props.minAspectRatio) {
+            assertRatio(props.minAspectRatio, "minAspectRatio");
+            assertRatioPositive(props.minAspectRatio, "minAspectRatio");
+        }
+        if (props.maxAspectRatio) {
+            assertRatio(props.maxAspectRatio, "maxAspectRatio");
+            assertRatioPositive(props.maxAspectRatio, "maxAspectRatio");
+        }
+        if (props.minAspectRatio && props.maxAspectRatio) {
+            const minValue = (0, ratio_1.ratioToFloat)(props.minAspectRatio);
+            const maxValue = (0, ratio_1.ratioToFloat)(props.maxAspectRatio);
+            assertCondition(minValue <= maxValue, "minAspectRatio must be less than or equal to maxAspectRatio");
+        }
+    };
+    const validateStyleValues = (props) => {
+        if (!props.style)
+            return;
+        const entries = Object.entries(props.style);
+        assertCondition(entries.length > 0, "style conditions must not be empty.");
+        entries.forEach(([name, value]) => {
+            if (value === undefined || value === null)
+                return;
+            if (Array.isArray(value)) {
+                assertCondition(value.length > 0, `style.${name} must not be empty`);
+                value.forEach((entry, index) => {
+                    assertCondition(isStyleValue(entry), `style.${name}[${index}] must be a primitive or measurement`);
+                });
+                return;
+            }
+            assertCondition(isStyleValue(value), `style.${name} must be a primitive or measurement`);
+        });
+    };
+    const validateCustomFeatures = (props) => {
+        if (!props.customFeatures)
+            return;
+        const entries = Object.entries(props.customFeatures);
+        assertCondition(entries.length > 0, "customFeatures should not be empty.");
+        entries.forEach(([name, value]) => {
+            const trimmedName = name.trim();
+            assertCondition(trimmedName.length > 0, "Custom feature name must be non-empty.");
+            if (value === undefined || value === null)
+                return;
+            assertCondition(isStyleValue(value), `Custom feature "${trimmedName}" must be a primitive or a measurement.`);
+        });
+    };
+    return {
+        runContainerQueryValidation,
+        validateMinMaxWidth,
+        validateWidthValuesPositive,
+        validateMinMaxHeight,
+        validateHeightValuesPositive,
+        validateInlineSizeValues,
+        validateBlockSizeValues,
+        validateAspectRatioValues,
+        validateStyleValues,
+        validateCustomFeatures,
+    };
+};
+exports.createContainerQueryValidation = createContainerQueryValidation;
+const defaultContainerQueryValidation = (0, exports.createContainerQueryValidation)({
+    assertCondition: core_1.assertCondition,
+    assertMatchingUnits: core_1.assertMatchingUnits,
+});
+exports.defaultContainerQueryValidation = defaultContainerQueryValidation;
+exports.runContainerQueryValidation = defaultContainerQueryValidation.runContainerQueryValidation, exports.validateMinMaxWidth = defaultContainerQueryValidation.validateMinMaxWidth, exports.validateWidthValuesPositive = defaultContainerQueryValidation.validateWidthValuesPositive, exports.validateMinMaxHeight = defaultContainerQueryValidation.validateMinMaxHeight, exports.validateHeightValuesPositive = defaultContainerQueryValidation.validateHeightValuesPositive, exports.validateInlineSizeValues = defaultContainerQueryValidation.validateInlineSizeValues, exports.validateBlockSizeValues = defaultContainerQueryValidation.validateBlockSizeValues, exports.validateAspectRatioValues = defaultContainerQueryValidation.validateAspectRatioValues, exports.validateStyleValues = defaultContainerQueryValidation.validateStyleValues, exports.validateCustomFeatures = defaultContainerQueryValidation.validateCustomFeatures;

package/dist/examples/src/core.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyRatio = exports.reduceRatio = exports.r = exports.parseRatio = exports.normalizeRatio = exports.isRatio = exports.ratioToFloat = exports.setErrorConfig = exports.getErrorConfig = exports.assertCondition = exports.assertUnit = exports.hasCssMethod = exports.makeUnitAssert = exports.makeUnitGuard = exports.makeUnitHelperFromDefinition = exports.makeUnitHelper = exports.measurementUnitMetadata = exports.measurementMax = exports.measurementMin = exports.assertMatchingUnits = exports.isMeasurement = exports.m = void 0;
+const createCoreApi_1 = require("./internal/createCoreApi");
+const errors_1 = require("./internal/errors");
+const ratio_1 = require("./ratio");
+Object.defineProperty(exports, "isRatio", { enumerable: true, get: function () { return ratio_1.isRatio; } });
+Object.defineProperty(exports, "normalizeRatio", { enumerable: true, get: function () { return ratio_1.normalizeRatio; } });
+Object.defineProperty(exports, "parseRatio", { enumerable: true, get: function () { return ratio_1.parseRatio; } });
+Object.defineProperty(exports, "r", { enumerable: true, get: function () { return ratio_1.r; } });
+Object.defineProperty(exports, "ratioToFloat", { enumerable: true, get: function () { return ratio_1.ratioToFloat; } });
+Object.defineProperty(exports, "reduceRatio", { enumerable: true, get: function () { return ratio_1.reduceRatio; } });
+Object.defineProperty(exports, "simplifyRatio", { enumerable: true, get: function () { return ratio_1.simplifyRatio; } });
+const defaultErrorStore = (0, errors_1.createErrorConfigStore)();
+const coreApi = (0, createCoreApi_1.createCoreApi)(defaultErrorStore);
+exports.m = coreApi.m, exports.isMeasurement = coreApi.isMeasurement, exports.assertMatchingUnits = coreApi.assertMatchingUnits, exports.measurementMin = coreApi.measurementMin, exports.measurementMax = coreApi.measurementMax, exports.measurementUnitMetadata = coreApi.measurementUnitMetadata, exports.makeUnitHelper = coreApi.makeUnitHelper, exports.makeUnitHelperFromDefinition = coreApi.makeUnitHelperFromDefinition, exports.makeUnitGuard = coreApi.makeUnitGuard, exports.makeUnitAssert = coreApi.makeUnitAssert, exports.hasCssMethod = coreApi.hasCssMethod, exports.assertUnit = coreApi.assertUnit, exports.assertCondition = coreApi.assertCondition, exports.getErrorConfig = coreApi.getErrorConfig, exports.setErrorConfig = coreApi.setErrorConfig;

package/dist/examples/src/factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCalipers = void 0;
+const errors_1 = require("./internal/errors");
+const createCoreApi_1 = require("./internal/createCoreApi");
+const createUnitsApi_1 = require("./internal/createUnitsApi");
+const createMediaQueriesApi_1 = require("./internal/createMediaQueriesApi");
+const createCalipers = (config = {}) => {
+    var _a;
+    const errorStore = (0, errors_1.createErrorConfigStore)((_a = config.errorConfig) !== null && _a !== void 0 ? _a : {});
+    const core = (0, createCoreApi_1.createCoreApi)(errorStore);
+    const units = (0, createUnitsApi_1.createUnitsApi)(core);
+    const mediaQueries = (0, createMediaQueriesApi_1.createMediaQueriesApi)(core);
+    return {
+        ...core,
+        ...units,
+        mediaQueries,
+        units,
+    };
+};
+exports.createCalipers = createCalipers;

package/dist/examples/src/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core"), exports);
+__exportStar(require("./units/percent"), exports);
+__exportStar(require("./units/absolute"), exports);
+__exportStar(require("./units/font-relative"), exports);
+__exportStar(require("./units/viewport"), exports);
+__exportStar(require("./units/viewport-small"), exports);
+__exportStar(require("./units/viewport-large"), exports);
+__exportStar(require("./units/viewport-dynamic"), exports);
+__exportStar(require("./units/container"), exports);
+__exportStar(require("./units/angle"), exports);
+__exportStar(require("./units/time"), exports);
+__exportStar(require("./units/frequency"), exports);
+__exportStar(require("./units/resolution"), exports);
+__exportStar(require("./units/grid"), exports);

package/dist/examples/src/internal/buildMeasurementCreationError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMeasurementCreationError = void 0;
+const buildMeasurementCreationError = (value, unit, helper, context) => {
+    const code = 'CALIPERS_E_NONFINITE';
+    return {
+        message: `Non-finite measurement value: ${value}`,
+        context,
+        details: {
+            code,
+            helper,
+            inputSummary: `value=${value}, unit=${unit}`,
+        },
+    };
+};
+exports.buildMeasurementCreationError = buildMeasurementCreationError;

package/dist/examples/src/internal/createCoreApi.js

@@ -0,0 +1,336 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoreApi = void 0;
+const unitDefinitions_1 = require("../unitDefinitions");
+const buildMeasurementCreationError_1 = require("./buildMeasurementCreationError");
+const errors_1 = require("./errors");
+const createCoreApi = (errorStore) => {
+    var _Measurement_instances, _a, _Measurement_value, _Measurement_unit, _Measurement_clone;
+    const { throwHelperError, throwMeasurementMethodError } = (0, errors_1.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 = (0, buildMeasurementCreationError_1.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 = (0, buildMeasurementCreationError_1.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(unitDefinitions_1.UNIT_DEFINITIONS[name].unit, name);
+    const measurementUnitMetadata = unitDefinitions_1.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,
+    };
+};
+exports.createCoreApi = createCoreApi;