css-calipers 0.9.3 → 0.9.5

package/dist/cjs/core.js

@@ -1,281 +1,8 @@
 "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);
-};
-var _Measurement_instances, _a, _Measurement_value, _Measurement_unit, _Measurement_clone;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertCondition = exports.assertUnit = exports.measurementMax = exports.measurementMin = exports.hasCssMethod = exports.makeUnitAssert = exports.makeUnitGuard = exports.measurementUnitMetadata = exports.makeUnitHelperFromDefinition = exports.makeUnitHelper = exports.isMeasurement = void 0;
-exports.assertMatchingUnits = assertMatchingUnits;
-exports.m = m;
-const unitDefinitions_1 = require("./unitDefinitions");
+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");
-function assertMatchingUnits(left, right, context) {
-    const leftUnit = left.getUnit();
-    const rightUnit = right.getUnit();
-    if (leftUnit !== rightUnit) {
-        (0, errors_1.throwHelperError)({
-            operation: 'css-calipers.assertMatchingUnits',
-            params: [left, right],
-            message: `measurement unit mismatch: ${leftUnit} vs ${rightUnit}`,
-            context,
-        });
-    }
-}
-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)) {
-            (0, errors_1.throwHelperError)({
-                operation: 'css-calipers.Measurement.constructor',
-                params: [],
-                message: `Non-finite measurement value: ${value}`,
-            });
-        }
-        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)) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.assertUnit',
-                caller: this,
-                params: [],
-                message: `Expected unit "${expected}", received "${__classPrivateFieldGet(this, _Measurement_unit, "f")}".`,
-                context,
-            });
-        }
-    }
-    assert(predicate, message) {
-        if (!predicate(this)) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.assert',
-                caller: this,
-                params: [],
-                message,
-            });
-        }
-    }
-    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) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.divide',
-                caller: this,
-                params: [],
-                message: `Cannot divide ${this.css()} by zero`,
-            });
-        }
-        const result = __classPrivateFieldGet(this, _Measurement_value, "f") / divisor;
-        if (!Number.isFinite(result)) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.divide',
-                caller: this,
-                params: [],
-                message: 'Non-finite 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)) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.clamp',
-                caller: this,
-                params: [min, max],
-                message: 'clamp: expected finite bounds',
-            });
-        }
-        if (minValue > maxValue) {
-            (0, errors_1.throwMeasurementMethodError)({
-                operation: 'css-calipers.Measurement.clamp',
-                caller: this,
-                params: [min, max],
-                message: `clamp: min (${min.css()}) must be <= max (${max.css()})`,
-            });
-        }
-        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;
-exports.isMeasurement = isMeasurement;
-function m(value, unit = 'px') {
-    return createMeasurement(value, unit.toLowerCase());
-}
-const makeUnitHelper = (unit) => {
-    const normalizedUnit = unit.toLowerCase();
-    const factory = (value) => createMeasurement(value, normalizedUnit);
-    return Object.assign(factory, {
-        unit: normalizedUnit,
-    });
-};
-exports.makeUnitHelper = makeUnitHelper;
-const makeUnitHelperFromDefinition = (name) => (0, exports.makeUnitHelper)(unitDefinitions_1.UNIT_DEFINITIONS[name].unit);
-exports.makeUnitHelperFromDefinition = makeUnitHelperFromDefinition;
-exports.measurementUnitMetadata = unitDefinitions_1.UNIT_DEFINITIONS;
-const makeUnitGuard = (helper) => {
-    return (value) => (0, exports.isMeasurement)(value) && value.isUnit(helper.unit);
-};
-exports.makeUnitGuard = makeUnitGuard;
-const makeUnitAssert = (helper) => {
-    const guard = (0, exports.makeUnitGuard)(helper);
-    return (value, context) => {
-        if (!guard(value)) {
-            (0, errors_1.throwHelperError)({
-                operation: 'css-calipers.makeUnitAssert',
-                params: (0, exports.isMeasurement)(value) ? [value] : [],
-                message: `Expected unit "${helper.unit}".`,
-                context,
-            });
-        }
-    };
-};
-exports.makeUnitAssert = makeUnitAssert;
-const hasCssMethod = (x) => {
-    return (typeof x === 'object' &&
-        x !== null &&
-        'css' in x &&
-        typeof x.css === 'function');
-};
-exports.hasCssMethod = hasCssMethod;
-const measurementMin = (a, b) => {
-    assertMatchingUnits(a, b, 'measurementMin');
-    return a.getValue() <= b.getValue() ? a : b;
-};
-exports.measurementMin = measurementMin;
-const measurementMax = (a, b) => {
-    assertMatchingUnits(a, b, 'measurementMax');
-    return a.getValue() >= b.getValue() ? a : b;
-};
-exports.measurementMax = measurementMax;
-const assertUnit = (measurement, expectedUnit, context) => measurement.assertUnit(expectedUnit, context);
-exports.assertUnit = assertUnit;
-const assertCondition = (condition, message) => {
-    const passed = typeof condition === 'function' ? condition() : condition;
-    if (!passed) {
-        (0, errors_1.throwHelperError)({
-            operation: 'css-calipers.assertCondition',
-            params: [],
-            message,
-        });
-    }
-};
-exports.assertCondition = assertCondition;
+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/cjs/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/cjs/fraction.js

@@ -0,0 +1,139 @@
+"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);
+};
+var _FractionImpl_numerator, _FractionImpl_denominator, _FractionImpl_omitDenominatorWhenOne;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fractionToFloat = exports.simplifyFraction = exports.reduceFraction = exports.normalizeFraction = exports.parseRatio = exports.isFraction = void 0;
+exports.r = r;
+class FractionImpl {
+    constructor(numerator, denominator, options = {}) {
+        var _a;
+        _FractionImpl_numerator.set(this, void 0);
+        _FractionImpl_denominator.set(this, void 0);
+        _FractionImpl_omitDenominatorWhenOne.set(this, void 0);
+        if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
+            throw new Error('Fraction values must be finite numbers.');
+        }
+        if (denominator === 0) {
+            throw new Error('Fraction denominator cannot be zero.');
+        }
+        __classPrivateFieldSet(this, _FractionImpl_numerator, numerator, "f");
+        __classPrivateFieldSet(this, _FractionImpl_denominator, denominator, "f");
+        __classPrivateFieldSet(this, _FractionImpl_omitDenominatorWhenOne, (_a = options.omitDenominatorWhenOne) !== null && _a !== void 0 ? _a : false, "f");
+    }
+    numerator() {
+        return __classPrivateFieldGet(this, _FractionImpl_numerator, "f");
+    }
+    denominator() {
+        return __classPrivateFieldGet(this, _FractionImpl_denominator, "f");
+    }
+    withNumerator(numerator) {
+        return new FractionImpl(numerator, __classPrivateFieldGet(this, _FractionImpl_denominator, "f"));
+    }
+    withDenominator(denominator) {
+        return new FractionImpl(__classPrivateFieldGet(this, _FractionImpl_numerator, "f"), denominator);
+    }
+    valueOf() {
+        return __classPrivateFieldGet(this, _FractionImpl_numerator, "f") / __classPrivateFieldGet(this, _FractionImpl_denominator, "f");
+    }
+    css() {
+        if (__classPrivateFieldGet(this, _FractionImpl_omitDenominatorWhenOne, "f") && __classPrivateFieldGet(this, _FractionImpl_denominator, "f") === 1) {
+            return String(__classPrivateFieldGet(this, _FractionImpl_numerator, "f"));
+        }
+        return `${__classPrivateFieldGet(this, _FractionImpl_numerator, "f")}/${__classPrivateFieldGet(this, _FractionImpl_denominator, "f")}`;
+    }
+    toString() {
+        return this.css();
+    }
+}
+_FractionImpl_numerator = new WeakMap(), _FractionImpl_denominator = new WeakMap(), _FractionImpl_omitDenominatorWhenOne = new WeakMap();
+function r(numeratorOrDenominator, denominator) {
+    const numerator = denominator === undefined ? numeratorOrDenominator : numeratorOrDenominator;
+    const resolvedDenominator = denominator === undefined ? 1 : denominator;
+    return new FractionImpl(numerator, resolvedDenominator);
+}
+const isFraction = (value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        "css" in value &&
+        "numerator" in value &&
+        "denominator" in value &&
+        typeof value.css === "function" &&
+        typeof value.numerator === "function" &&
+        typeof value.denominator === "function");
+};
+exports.isFraction = isFraction;
+const parseRatio = (value) => {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? { numerator: value, denominator: 1 } : null;
+    }
+    if ((0, exports.isFraction)(value)) {
+        return { numerator: value.numerator(), denominator: value.denominator() };
+    }
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.includes("/")) {
+        const [left, right] = trimmed.split("/");
+        if (left === undefined || right === undefined)
+            return null;
+        const numerator = Number(left.trim());
+        const denominator = Number(right.trim());
+        if (!Number.isFinite(numerator) || !Number.isFinite(denominator))
+            return null;
+        if (denominator === 0)
+            return null;
+        return { numerator, denominator };
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? { numerator: parsed, denominator: 1 } : null;
+};
+exports.parseRatio = parseRatio;
+const normalizeFraction = (fraction) => {
+    let numerator = fraction.numerator();
+    let denominator = fraction.denominator();
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
+        throw new Error("Fraction values must be finite numbers.");
+    }
+    if (denominator === 0) {
+        throw new Error("Fraction denominator cannot be zero.");
+    }
+    if (!Number.isInteger(numerator) || !Number.isInteger(denominator)) {
+        return new FractionImpl(numerator, denominator);
+    }
+    if (denominator < 0) {
+        numerator = -numerator;
+        denominator = Math.abs(denominator);
+    }
+    const gcd = (a, b) => {
+        let x = Math.abs(a);
+        let y = Math.abs(b);
+        while (y !== 0) {
+            const next = x % y;
+            x = y;
+            y = next;
+        }
+        return x === 0 ? 1 : x;
+    };
+    const divisor = gcd(numerator, denominator);
+    return new FractionImpl(numerator / divisor, denominator / divisor);
+};
+exports.normalizeFraction = normalizeFraction;
+const reduceFraction = (fraction) => (0, exports.normalizeFraction)(fraction);
+exports.reduceFraction = reduceFraction;
+const simplifyFraction = (fraction) => {
+    const reduced = (0, exports.normalizeFraction)(fraction);
+    return new FractionImpl(reduced.numerator(), reduced.denominator(), { omitDenominatorWhenOne: true });
+};
+exports.simplifyFraction = simplifyFraction;
+const fractionToFloat = (fraction) => fraction.numerator() / fraction.denominator();
+exports.fractionToFloat = fractionToFloat;

package/dist/cjs/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/cjs/internal/buildMeasurementCreationError.tests.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMeasurementCreationError = void 0;
+var buildMeasurementCreationError_1 = require("./buildMeasurementCreationError");
+Object.defineProperty(exports, "buildMeasurementCreationError", { enumerable: true, get: function () { return buildMeasurementCreationError_1.buildMeasurementCreationError; } });

package/dist/cjs/internal/createComponentQueriesApi.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainerQueriesApi = void 0;
+const helpers_1 = require("../containerQueries/helpers");
+const validation_1 = require("../containerQueries/validation");
+const containerQueries_1 = require("../containerQueries/containerQueries");
+const modules_1 = require("../containerQueries/modules");
+const factory_1 = require("../containerQueries/factory");
+const vanilla_extract_1 = require("../libraryHelpers/vanilla-extract");
+const createContainerQueriesApi = (core) => {
+    const validation = (0, validation_1.createContainerQueryValidation)({
+        assertCondition: core.assertCondition,
+        assertMatchingUnits: core.assertMatchingUnits,
+    });
+    const emitCoreFeatures = (0, containerQueries_1.createEmitCoreFeatures)(validation);
+    const emitBaseFeatures = (props, helpers) => {
+        emitCoreFeatures(props, helpers);
+        (0, modules_1.emitAspectRatioFeatures)(props, helpers);
+        (0, modules_1.emitBlockSizeFeatures)(props, helpers);
+        (0, modules_1.emitInlineSizeFeatures)(props, helpers);
+        (0, modules_1.emitStyleFeatures)(props, helpers);
+        (0, modules_1.emitCustomFeatures)(props, helpers);
+    };
+    const buildContainerQueryString = (0, helpers_1.createContainerQueryBuilder)({
+        emitBase: emitBaseFeatures,
+    });
+    const makeContainerQueryStyle = (queries) => (stylesByQuery) => {
+        const result = {};
+        Object.keys(stylesByQuery).forEach((key) => {
+            const styles = stylesByQuery[key];
+            const props = queries[key];
+            if (!styles || !props)
+                return;
+            result[buildContainerQueryString(props)] = styles;
+        });
+        const containerQuery = {
+            "@container": result,
+        };
+        return containerQuery;
+    };
+    const containerQueryFactory = (0, factory_1.createContainerQueryFactory)();
+    return {
+        buildContainerQueryString,
+        makeContainerQueryStyle,
+        containerQueryFactory,
+        emitCoreFeatures,
+        emitAspectRatioFeatures: modules_1.emitAspectRatioFeatures,
+        emitBlockSizeFeatures: modules_1.emitBlockSizeFeatures,
+        emitInlineSizeFeatures: modules_1.emitInlineSizeFeatures,
+        emitStyleFeatures: modules_1.emitStyleFeatures,
+        emitCustomFeatures: modules_1.emitCustomFeatures,
+        containerQueryOutputVanillaExtract: vanilla_extract_1.containerQueryOutputVanillaExtract,
+        createContainerQueryBuilder: helpers_1.createContainerQueryBuilder,
+    };
+};
+exports.createContainerQueriesApi = createContainerQueriesApi;