css-calipers 0.9.3 → 0.9.5

package/dist/cjs/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;

package/dist/cjs/internal/createMediaQueriesApi.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaQueriesApi = void 0;
+const helpers_1 = require("../mediaQueries/helpers");
+const validation_1 = require("../mediaQueries/validation");
+const mediaQueries_1 = require("../mediaQueries/mediaQueries");
+const modules_1 = require("../mediaQueries/modules");
+const resolution_1 = require("../mediaQueries/modules/resolution");
+const factory_1 = require("../mediaQueries/factory");
+const vanilla_extract_1 = require("../mediaQueries/libraryHelpers/vanilla-extract");
+const createMediaQueriesApi = (core) => {
+    const validation = (0, validation_1.createMediaQueryValidation)({
+        assertCondition: core.assertCondition,
+        assertMatchingUnits: core.assertMatchingUnits,
+    });
+    const emitCoreFeatures = (0, mediaQueries_1.createEmitCoreFeatures)(validation);
+    const emitDimensionsFeatures = (0, modules_1.createEmitDimensionsFeatures)(validation);
+    const emitResolutionFeatures = (0, resolution_1.createEmitResolutionFeatures)(validation);
+    const emitBaseFeatures = (props, helpers) => {
+        emitCoreFeatures(props, helpers);
+        emitDimensionsFeatures(props, helpers);
+        emitResolutionFeatures(props, helpers);
+        (0, modules_1.emitInteractionFeatures)(props, helpers);
+        (0, modules_1.emitPreferencesFeatures)(props, helpers);
+        (0, modules_1.emitDisplayFeatures)(props, helpers);
+        (0, modules_1.emitEnvironmentFeatures)(props, helpers);
+        (0, modules_1.emitCustomFeatures)(props, helpers);
+    };
+    const buildMediaQueryString = (0, helpers_1.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: modules_1.emitInteractionFeatures,
+        preferences: modules_1.emitPreferencesFeatures,
+        display: modules_1.emitDisplayFeatures,
+        environment: modules_1.emitEnvironmentFeatures,
+        custom: modules_1.emitCustomFeatures,
+    };
+    const mediaQueryFactory = (0, factory_1.createMediaQueryFactory)(moduleEmitters);
+    return {
+        buildMediaQueryString,
+        makeMediaQueryStyle,
+        mediaQueryFactory,
+        emitCoreFeatures,
+        emitDimensionsFeatures,
+        emitResolutionFeatures,
+        emitInteractionFeatures: modules_1.emitInteractionFeatures,
+        emitPreferencesFeatures: modules_1.emitPreferencesFeatures,
+        emitDisplayFeatures: modules_1.emitDisplayFeatures,
+        emitEnvironmentFeatures: modules_1.emitEnvironmentFeatures,
+        emitCustomFeatures: modules_1.emitCustomFeatures,
+        mediaQueryOutputVanillaExtract: vanilla_extract_1.mediaQueryOutputVanillaExtract,
+        createMediaQueryBuilder: helpers_1.createMediaQueryBuilder,
+    };
+};
+exports.createMediaQueriesApi = createMediaQueriesApi;

package/dist/cjs/internal/createUnitsApi.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnitsApi = void 0;
+const unitDefinitions_1 = require("../unitDefinitions");
+const createUnitsApi = (core) => {
+    const helpers = Object.keys(unitDefinitions_1.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),
+    };
+};
+exports.createUnitsApi = createUnitsApi;

package/dist/cjs/internal/errors.js

@@ -1,17 +1,130 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwHelperError = exports.throwMeasurementMethodError = void 0;
-const formatErrorMessage = (operation, message, context) => {
+exports.throwHelperError = exports.throwMeasurementMethodError = exports.createErrorHelpers = exports.getErrorConfig = exports.setErrorConfig = exports.createErrorConfigStore = void 0;
+const DEFAULT_ERROR_CONFIG = {
+    stackHints: "auto",
+};
+let errorConfig = { ...DEFAULT_ERROR_CONFIG };
+const createErrorConfigStore = (initial = {}) => {
+    let config = {
+        ...DEFAULT_ERROR_CONFIG,
+        ...initial,
+    };
+    return {
+        getErrorConfig: () => config,
+        setErrorConfig: (next) => {
+            config = { ...config, ...next };
+        },
+    };
+};
+exports.createErrorConfigStore = createErrorConfigStore;
+const setErrorConfig = (next) => {
+    errorConfig = { ...errorConfig, ...next };
+};
+exports.setErrorConfig = setErrorConfig;
+const getErrorConfig = () => errorConfig;
+exports.getErrorConfig = getErrorConfig;
+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 };
+};
+exports.createErrorHelpers = createErrorHelpers;
+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. */
 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,
+    }));
 };
 exports.throwMeasurementMethodError = throwMeasurementMethodError;
 /** Throw an Error for a helper/free function using a structured context. */
 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,
+    }));
 };
 exports.throwHelperError = throwHelperError;

package/dist/cjs/internal/normalizeToArray.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToArray = void 0;
+const normalizeToArray = (value) => {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+};
+exports.normalizeToArray = normalizeToArray;

package/dist/cjs/libraryHelpers/vanilla-extract.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mediaQueryOutputVanillaExtract = void 0;
+exports.containerQueryOutputVanillaExtract = exports.mediaQueryOutputVanillaExtract = void 0;
 const mediaQueryOutputVanillaExtract = (media) => ({
-    '&': media,
+    "&": media,
 });
 exports.mediaQueryOutputVanillaExtract = mediaQueryOutputVanillaExtract;
+const containerQueryOutputVanillaExtract = (container) => ({
+    "&": container,
+});
+exports.containerQueryOutputVanillaExtract = containerQueryOutputVanillaExtract;

package/dist/cjs/logicalOperators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export type ContentQueryVariable =
+//   ContainerQueryModuleKeysMap[keyof ContainerQueryModuleKeysMap];
+// export type ContentQueryComparisonValue = IMeasurement | number | string;
+// export type Comparison<
+//   Variable = ContentQueryVariable,
+//   Value = ContentQueryComparisonValue
+// > = {
+//   variable: Variable;
+//   operator: IComparisonOperator;
+//   value: Value;
+// };
+// export type ComparisonValue<Value = ContentQueryComparisonValue> = {
+//   operator: IComparisonOperator;
+//   value: Value;
+//   readonly __comparisonBrand: unique symbol;
+// };

package/dist/cjs/mediaQueries/factory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mediaQueryFactory = void 0;
+exports.mediaQueryFactory = exports.createMediaQueryFactory = void 0;
 const helpers_1 = require("./helpers");
 const mediaQueries_1 = require("./mediaQueries");
 const modules_1 = require("./modules");
@@ -127,7 +127,7 @@ const runCustomLinter = (props, config) => {
         return;
     throw new Error(message);
 };
-const mediaQueryFactory = (options) => {
+const createMediaQueryFactory = (emitters) => (options) => {
     var _a;
     const modules = (_a = options.config.modules) !== null && _a !== void 0 ? _a : ALL_MEDIA_QUERY_MODULES;
     const buildMediaQuery = (0, helpers_1.createMediaQueryBuilder)({
@@ -136,7 +136,7 @@ const mediaQueryFactory = (options) => {
             runCustomValidator(props, options.config);
             runCustomLinter(props, options.config);
             modules.forEach((moduleId) => {
-                MODULE_EMITTERS[moduleId](props, helpers);
+                emitters[moduleId](props, helpers);
             });
         },
         resolveType: (props) => props.type,
@@ -159,4 +159,5 @@ const mediaQueryFactory = (options) => {
             : mediaQuery;
     };
 };
-exports.mediaQueryFactory = mediaQueryFactory;
+exports.createMediaQueryFactory = createMediaQueryFactory;
+exports.mediaQueryFactory = (0, exports.createMediaQueryFactory)(MODULE_EMITTERS);

package/dist/cjs/mediaQueries/mediaQueries.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMediaQueryStyle = exports.buildMediaQueryString = exports.emitCoreFeatures = void 0;
+exports.makeMediaQueryStyle = exports.buildMediaQueryString = exports.emitCoreFeatures = exports.createEmitCoreFeatures = void 0;
 const helpers_1 = require("./helpers");
 const validation_1 = require("./validation");
 const modules_1 = require("./modules");
-const emitCoreFeatures = (props, helpers) => {
-    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateMinMaxWidth, "core", "minWidth must be less than or equal to maxWidth")) {
+const createEmitCoreFeatures = (validation) => (props, helpers) => {
+    const { runMediaQueryValidation, validateMinMaxWidth, validateWidthValuesPositive, } = validation;
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxWidth, "core", "minWidth must be less than or equal to maxWidth")) {
         return;
     }
-    if (!(0, validation_1.runMediaQueryValidation)(props, helpers, validation_1.validateWidthValuesPositive, "core", "width values must be greater than 0")) {
+    if (!runMediaQueryValidation(props, helpers, validateWidthValuesPositive, "core", "width values must be greater than 0")) {
         return;
     }
     const { addFeature } = helpers;
@@ -19,7 +20,8 @@ const emitCoreFeatures = (props, helpers) => {
         addFeature("max-width", props.maxWidth);
     }
 };
-exports.emitCoreFeatures = emitCoreFeatures;
+exports.createEmitCoreFeatures = createEmitCoreFeatures;
+exports.emitCoreFeatures = (0, exports.createEmitCoreFeatures)(validation_1.defaultMediaQueryValidation);
 const emitBaseFeatures = (props, helpers) => {
     (0, exports.emitCoreFeatures)(props, helpers);
     (0, modules_1.emitDimensionsFeatures)(props, helpers);