css-calipers 0.9.3 → 0.9.4

package/dist/examples/src/mediaQueries/modules/dimensions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitDimensionsFeatures = exports.createEmitDimensionsFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const core_1 = require("../linting/core");
+const createEmitDimensionsFeatures = (validation) => (props, helpers, validate) => {
+    const { runMediaQueryValidation, validateMinMaxHeight, validateHeightValuesPositive, validateMinMaxAspectRatio, validateAspectRatioValuesPositive, validateWidthValuesPositive, } = validation;
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxHeight, 'dimensions', 'minHeight must be less than or equal to maxHeight')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateHeightValuesPositive, 'dimensions', 'height values must be greater than 0')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, core_1.lintWidthRedundancy, 'width should not be combined with minWidth or maxWidth')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, core_1.lintHeightRedundancy, 'height should not be combined with minHeight or maxHeight')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateWidthValuesPositive, 'dimensions', 'width values must be greater than 0')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateMinMaxAspectRatio, 'dimensions', 'minAspectRatio must be less than or equal to maxAspectRatio')) {
+        return;
+    }
+    if (!runMediaQueryValidation(props, helpers, validateAspectRatioValuesPositive, 'dimensions', 'aspect ratio values must be greater than 0')) {
+        return;
+    }
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'dimensions')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.width) {
+        addFeature('width', props.width);
+    }
+    if (props.height) {
+        addFeature('height', props.height);
+    }
+    if (props.minHeight) {
+        addFeature('min-height', props.minHeight);
+    }
+    if (props.maxHeight) {
+        addFeature('max-height', props.maxHeight);
+    }
+    if (props.aspectRatio) {
+        addFeature('aspect-ratio', props.aspectRatio);
+    }
+    if (props.minAspectRatio) {
+        addFeature('min-aspect-ratio', props.minAspectRatio);
+    }
+    if (props.maxAspectRatio) {
+        addFeature('max-aspect-ratio', props.maxAspectRatio);
+    }
+    if (props.orientation) {
+        addFeature('orientation', props.orientation);
+    }
+};
+exports.createEmitDimensionsFeatures = createEmitDimensionsFeatures;
+exports.emitDimensionsFeatures = (0, exports.createEmitDimensionsFeatures)(validation_1.defaultMediaQueryValidation);

package/dist/examples/src/mediaQueries/modules/display.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitDisplayFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitDisplayFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'display')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.colorGamut) {
+        addFeature('color-gamut', props.colorGamut);
+    }
+    if (props.dynamicRange) {
+        addFeature('dynamic-range', props.dynamicRange);
+    }
+    if (props.invertedColors) {
+        addFeature('inverted-colors', props.invertedColors);
+    }
+};
+exports.emitDisplayFeatures = emitDisplayFeatures;

package/dist/examples/src/mediaQueries/modules/environment.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEnvironmentFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitEnvironmentFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'environment')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.scripting) {
+        addFeature('scripting', props.scripting);
+    }
+    if (props.overflowBlock) {
+        addFeature('overflow-block', props.overflowBlock);
+    }
+    if (props.overflowInline) {
+        addFeature('overflow-inline', props.overflowInline);
+    }
+};
+exports.emitEnvironmentFeatures = emitEnvironmentFeatures;

package/dist/examples/src/mediaQueries/modules/index.js

@@ -0,0 +1,23 @@
+"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("./custom"), exports);
+__exportStar(require("./dimensions"), exports);
+__exportStar(require("./display"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./interaction"), exports);
+__exportStar(require("./preferences"), exports);
+__exportStar(require("./resolution"), exports);

package/dist/examples/src/mediaQueries/modules/interaction.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitInteractionFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitInteractionFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'interaction')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.hover) {
+        addFeature('hover', props.hover);
+    }
+    if (props.anyHover) {
+        addFeature('any-hover', props.anyHover);
+    }
+    if (props.pointer) {
+        addFeature('pointer', props.pointer);
+    }
+    if (props.anyPointer) {
+        addFeature('any-pointer', props.anyPointer);
+    }
+    if (props.update) {
+        addFeature('update', props.update);
+    }
+};
+exports.emitInteractionFeatures = emitInteractionFeatures;

package/dist/examples/src/mediaQueries/modules/preferences.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPreferencesFeatures = void 0;
+const helpers_1 = require("../helpers");
+const emitPreferencesFeatures = (props, helpers, validate) => {
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'preferences')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.colorScheme) {
+        addFeature('prefers-color-scheme', props.colorScheme);
+    }
+    if (props.reducedMotion) {
+        addFeature('prefers-reduced-motion', props.reducedMotion);
+    }
+    if (props.reducedData) {
+        addFeature('prefers-reduced-data', props.reducedData);
+    }
+    if (props.contrast) {
+        addFeature('prefers-contrast', props.contrast);
+    }
+    if (props.forcedColors) {
+        addFeature('forced-colors', props.forcedColors);
+    }
+};
+exports.emitPreferencesFeatures = emitPreferencesFeatures;

package/dist/examples/src/mediaQueries/modules/resolution.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitResolutionFeatures = exports.createEmitResolutionFeatures = void 0;
+const helpers_1 = require("../helpers");
+const validation_1 = require("../validation");
+const linting_1 = require("../linting");
+const resolution_1 = require("../linting/resolution");
+const createEmitResolutionFeatures = (validation) => (props, helpers, validate) => {
+    const { runMediaQueryValidation, validateResolutionValues } = validation;
+    if (!runMediaQueryValidation(props, helpers, validateResolutionValues, 'resolution', 'resolution values must be greater than 0')) {
+        return;
+    }
+    if (!(0, linting_1.runMediaQueryLint)(props, helpers, resolution_1.lintResolutionRedundancy, 'resolution should not be combined with minResolution or maxResolution')) {
+        return;
+    }
+    if (!(0, helpers_1.applyMediaQueryValidation)(props, helpers, validate, 'resolution')) {
+        return;
+    }
+    const { addFeature } = helpers;
+    if (props.resolutionValue) {
+        addFeature('resolution', props.resolutionValue);
+    }
+    if (props.minResolution) {
+        addFeature('min-resolution', props.minResolution);
+    }
+    if (props.maxResolution) {
+        addFeature('max-resolution', props.maxResolution);
+    }
+};
+exports.createEmitResolutionFeatures = createEmitResolutionFeatures;
+exports.emitResolutionFeatures = (0, exports.createEmitResolutionFeatures)(validation_1.defaultMediaQueryValidation);

package/dist/examples/src/mediaQueries/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMediaQueryValidation = exports.validateResolutionValues = exports.validateAspectRatioValuesPositive = exports.validateMinMaxAspectRatio = exports.validateHeightValuesPositive = exports.validateMinMaxHeight = exports.validateWidthValuesPositive = exports.validateMinMaxWidth = exports.runMediaQueryValidation = exports.createMediaQueryValidation = void 0;
+const helpers_1 = require("./helpers");
+const core_1 = require("../core");
+const toValidationResult = (error, fallback) => {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return fallback;
+};
+const createMediaQueryValidation = (core) => {
+    const { assertCondition, assertMatchingUnits } = core;
+    const runMediaQueryValidation = (config, helpers, check, context, fallbackMessage = "Invalid media query configuration") => {
+        if (!check)
+            return true;
+        try {
+            check(config);
+            return true;
+        }
+        catch (error) {
+            const result = toValidationResult(error, fallbackMessage);
+            return (0, helpers_1.applyMediaQueryValidation)(config, helpers, () => result, context);
+        }
+    };
+    const validateMinMaxWidth = (props) => {
+        if (!props.minWidth || !props.maxWidth)
+            return;
+        assertMatchingUnits(props.minWidth, props.maxWidth, "mediaQueries.minMaxWidth");
+        assertCondition(props.minWidth.getValue() <= props.maxWidth.getValue(), "minWidth must be less than or equal to maxWidth");
+    };
+    const validateWidthValuesPositive = (props) => {
+        const assertPositive = (value, label) => {
+            assertCondition(value.getValue() > 0, `${label} must be greater than 0`);
+        };
+        if (props.width) {
+            assertPositive(props.width, "width");
+        }
+        if (props.minWidth) {
+            assertPositive(props.minWidth, "minWidth");
+        }
+        if (props.maxWidth) {
+            assertPositive(props.maxWidth, "maxWidth");
+        }
+    };
+    const validateMinMaxHeight = (props) => {
+        if (!props.minHeight || !props.maxHeight)
+            return;
+        assertMatchingUnits(props.minHeight, props.maxHeight, "mediaQueries.minMaxHeight");
+        assertCondition(props.minHeight.getValue() <= props.maxHeight.getValue(), "minHeight must be less than or equal to maxHeight");
+    };
+    const validateHeightValuesPositive = (props) => {
+        const assertPositive = (value, label) => {
+            assertCondition(value.getValue() > 0, `${label} must be greater than 0`);
+        };
+        if (props.height) {
+            assertPositive(props.height, "height");
+        }
+        if (props.minHeight) {
+            assertPositive(props.minHeight, "minHeight");
+        }
+        if (props.maxHeight) {
+            assertPositive(props.maxHeight, "maxHeight");
+        }
+    };
+    const assertRatio = (value, label) => {
+        assertCondition((0, core_1.isRatio)(value), `${label} must be a ratio created with r()`);
+    };
+    const assertRatioPositive = (value, label) => {
+        assertCondition(value.numerator() > 0 && value.denominator() > 0, `${label} must be a valid ratio greater than 0`);
+    };
+    const validateMinMaxAspectRatio = (props) => {
+        if (!props.minAspectRatio || !props.maxAspectRatio)
+            return;
+        assertRatio(props.minAspectRatio, "minAspectRatio");
+        assertRatio(props.maxAspectRatio, "maxAspectRatio");
+        const minRatio = (0, core_1.ratioToFloat)(props.minAspectRatio);
+        const maxRatio = (0, core_1.ratioToFloat)(props.maxAspectRatio);
+        assertCondition(minRatio <= maxRatio, "minAspectRatio must be less than or equal to maxAspectRatio");
+    };
+    const validateAspectRatioValuesPositive = (props) => {
+        if (props.aspectRatio !== undefined) {
+            assertRatio(props.aspectRatio, "aspectRatio");
+            assertRatioPositive(props.aspectRatio, "aspectRatio");
+        }
+        if (props.minAspectRatio !== undefined) {
+            assertRatio(props.minAspectRatio, "minAspectRatio");
+            assertRatioPositive(props.minAspectRatio, "minAspectRatio");
+        }
+        if (props.maxAspectRatio !== undefined) {
+            assertRatio(props.maxAspectRatio, "maxAspectRatio");
+            assertRatioPositive(props.maxAspectRatio, "maxAspectRatio");
+        }
+    };
+    const validateResolutionValues = (props) => {
+        const assertPositive = (value, label) => {
+            assertCondition(value.getValue() > 0, `${label} must be greater than 0`);
+        };
+        if (props.resolutionValue) {
+            assertPositive(props.resolutionValue, "resolution");
+        }
+        if (props.minResolution) {
+            assertPositive(props.minResolution, "minResolution");
+        }
+        if (props.maxResolution) {
+            assertPositive(props.maxResolution, "maxResolution");
+        }
+        if (props.minResolution && props.maxResolution) {
+            assertMatchingUnits(props.minResolution, props.maxResolution, "mediaQueries.resolutionUnits");
+        }
+    };
+    return {
+        runMediaQueryValidation,
+        validateMinMaxWidth,
+        validateWidthValuesPositive,
+        validateMinMaxHeight,
+        validateHeightValuesPositive,
+        validateMinMaxAspectRatio,
+        validateAspectRatioValuesPositive,
+        validateResolutionValues,
+    };
+};
+exports.createMediaQueryValidation = createMediaQueryValidation;
+const defaultMediaQueryValidation = (0, exports.createMediaQueryValidation)({
+    assertCondition: core_1.assertCondition,
+    assertMatchingUnits: core_1.assertMatchingUnits,
+});
+exports.defaultMediaQueryValidation = defaultMediaQueryValidation;
+exports.runMediaQueryValidation = defaultMediaQueryValidation.runMediaQueryValidation, exports.validateMinMaxWidth = defaultMediaQueryValidation.validateMinMaxWidth, exports.validateWidthValuesPositive = defaultMediaQueryValidation.validateWidthValuesPositive, exports.validateMinMaxHeight = defaultMediaQueryValidation.validateMinMaxHeight, exports.validateHeightValuesPositive = defaultMediaQueryValidation.validateHeightValuesPositive, exports.validateMinMaxAspectRatio = defaultMediaQueryValidation.validateMinMaxAspectRatio, exports.validateAspectRatioValuesPositive = defaultMediaQueryValidation.validateAspectRatioValuesPositive, exports.validateResolutionValues = defaultMediaQueryValidation.validateResolutionValues;

package/dist/examples/src/ratio.js

@@ -0,0 +1,141 @@
+"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 _RatioImpl_numerator, _RatioImpl_denominator, _RatioImpl_omitDenominatorWhenOne;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ratioToFloat = exports.simplifyRatio = exports.reduceRatio = exports.normalizeRatio = exports.parseRatio = exports.isRatio = void 0;
+exports.r = r;
+class RatioImpl {
+    constructor(numerator, denominator, options = {}) {
+        var _a;
+        _RatioImpl_numerator.set(this, void 0);
+        _RatioImpl_denominator.set(this, void 0);
+        _RatioImpl_omitDenominatorWhenOne.set(this, void 0);
+        if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
+            throw new Error("Ratio values must be finite numbers.");
+        }
+        if (denominator === 0) {
+            throw new Error("Ratio denominator cannot be zero.");
+        }
+        __classPrivateFieldSet(this, _RatioImpl_numerator, numerator, "f");
+        __classPrivateFieldSet(this, _RatioImpl_denominator, denominator, "f");
+        __classPrivateFieldSet(this, _RatioImpl_omitDenominatorWhenOne, (_a = options.omitDenominatorWhenOne) !== null && _a !== void 0 ? _a : false, "f");
+    }
+    numerator() {
+        return __classPrivateFieldGet(this, _RatioImpl_numerator, "f");
+    }
+    denominator() {
+        return __classPrivateFieldGet(this, _RatioImpl_denominator, "f");
+    }
+    withNumerator(numerator) {
+        return new RatioImpl(numerator, __classPrivateFieldGet(this, _RatioImpl_denominator, "f"));
+    }
+    withDenominator(denominator) {
+        return new RatioImpl(__classPrivateFieldGet(this, _RatioImpl_numerator, "f"), denominator);
+    }
+    valueOf() {
+        return __classPrivateFieldGet(this, _RatioImpl_numerator, "f") / __classPrivateFieldGet(this, _RatioImpl_denominator, "f");
+    }
+    css() {
+        if (__classPrivateFieldGet(this, _RatioImpl_omitDenominatorWhenOne, "f") && __classPrivateFieldGet(this, _RatioImpl_denominator, "f") === 1) {
+            return String(__classPrivateFieldGet(this, _RatioImpl_numerator, "f"));
+        }
+        return `${__classPrivateFieldGet(this, _RatioImpl_numerator, "f")}/${__classPrivateFieldGet(this, _RatioImpl_denominator, "f")}`;
+    }
+    toString() {
+        return this.css();
+    }
+}
+_RatioImpl_numerator = new WeakMap(), _RatioImpl_denominator = new WeakMap(), _RatioImpl_omitDenominatorWhenOne = new WeakMap();
+function r(numeratorOrDenominator, denominator) {
+    const numerator = denominator === undefined ? numeratorOrDenominator : numeratorOrDenominator;
+    const resolvedDenominator = denominator === undefined ? 1 : denominator;
+    return new RatioImpl(numerator, resolvedDenominator);
+}
+const isRatio = (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.isRatio = isRatio;
+const parseRatio = (value) => {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? { numerator: value, denominator: 1 } : null;
+    }
+    if ((0, exports.isRatio)(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 normalizeRatio = (ratio) => {
+    let numerator = ratio.numerator();
+    let denominator = ratio.denominator();
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
+        throw new Error("Ratio values must be finite numbers.");
+    }
+    if (denominator === 0) {
+        throw new Error("Ratio denominator cannot be zero.");
+    }
+    if (!Number.isInteger(numerator) || !Number.isInteger(denominator)) {
+        return new RatioImpl(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 RatioImpl(numerator / divisor, denominator / divisor);
+};
+exports.normalizeRatio = normalizeRatio;
+const reduceRatio = (ratio) => (0, exports.normalizeRatio)(ratio);
+exports.reduceRatio = reduceRatio;
+const simplifyRatio = (ratio) => {
+    const reduced = (0, exports.normalizeRatio)(ratio);
+    return new RatioImpl(reduced.numerator(), reduced.denominator(), {
+        omitDenominatorWhenOne: true,
+    });
+};
+exports.simplifyRatio = simplifyRatio;
+const ratioToFloat = (ratio) => ratio.numerator() / ratio.denominator();
+exports.ratioToFloat = ratioToFloat;

package/dist/examples/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/examples/src/unitDefinitions.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIT_DEFINITIONS = void 0;
+exports.UNIT_DEFINITIONS = {
+    mPercent: { unit: '%', category: 'percent' },
+    mPx: { unit: 'px', category: 'length-absolute' },
+    mCm: { unit: 'cm', category: 'length-absolute' },
+    mMm: { unit: 'mm', category: 'length-absolute' },
+    mQ: { unit: 'q', category: 'length-absolute' },
+    mIn: { unit: 'in', category: 'length-absolute' },
+    mPc: { unit: 'pc', category: 'length-absolute' },
+    mPt: { unit: 'pt', category: 'length-absolute' },
+    mEm: { unit: 'em', category: 'length-font-relative' },
+    mRem: { unit: 'rem', category: 'length-font-relative' },
+    mEx: { unit: 'ex', category: 'length-font-relative' },
+    mRex: { unit: 'rex', category: 'length-font-relative' },
+    mCh: { unit: 'ch', category: 'length-font-relative' },
+    mRch: { unit: 'rch', category: 'length-font-relative' },
+    mCap: { unit: 'cap', category: 'length-font-relative' },
+    mRcap: { unit: 'rcap', category: 'length-font-relative' },
+    mIc: { unit: 'ic', category: 'length-font-relative' },
+    mRic: { unit: 'ric', category: 'length-font-relative' },
+    mLh: { unit: 'lh', category: 'length-font-relative' },
+    mRlh: { unit: 'rlh', category: 'length-font-relative' },
+    mVw: { unit: 'vw', category: 'length-viewport' },
+    mVh: { unit: 'vh', category: 'length-viewport' },
+    mVi: { unit: 'vi', category: 'length-viewport' },
+    mVb: { unit: 'vb', category: 'length-viewport' },
+    mVmin: { unit: 'vmin', category: 'length-viewport' },
+    mVmax: { unit: 'vmax', category: 'length-viewport' },
+    mSvw: { unit: 'svw', category: 'length-viewport-small' },
+    mSvh: { unit: 'svh', category: 'length-viewport-small' },
+    mSvi: { unit: 'svi', category: 'length-viewport-small' },
+    mSvb: { unit: 'svb', category: 'length-viewport-small' },
+    mSvmin: { unit: 'svmin', category: 'length-viewport-small' },
+    mSvmax: { unit: 'svmax', category: 'length-viewport-small' },
+    mLvw: { unit: 'lvw', category: 'length-viewport-large' },
+    mLvh: { unit: 'lvh', category: 'length-viewport-large' },
+    mLvi: { unit: 'lvi', category: 'length-viewport-large' },
+    mLvb: { unit: 'lvb', category: 'length-viewport-large' },
+    mLvmin: { unit: 'lvmin', category: 'length-viewport-large' },
+    mLvmax: { unit: 'lvmax', category: 'length-viewport-large' },
+    mDvw: { unit: 'dvw', category: 'length-viewport-dynamic' },
+    mDvh: { unit: 'dvh', category: 'length-viewport-dynamic' },
+    mDvi: { unit: 'dvi', category: 'length-viewport-dynamic' },
+    mDvb: { unit: 'dvb', category: 'length-viewport-dynamic' },
+    mDvmin: { unit: 'dvmin', category: 'length-viewport-dynamic' },
+    mDvmax: { unit: 'dvmax', category: 'length-viewport-dynamic' },
+    mCqw: { unit: 'cqw', category: 'length-container' },
+    mCqh: { unit: 'cqh', category: 'length-container' },
+    mCqi: { unit: 'cqi', category: 'length-container' },
+    mCqb: { unit: 'cqb', category: 'length-container' },
+    mCqmin: { unit: 'cqmin', category: 'length-container' },
+    mCqmax: { unit: 'cqmax', category: 'length-container' },
+    mDeg: { unit: 'deg', category: 'angle' },
+    mRad: { unit: 'rad', category: 'angle' },
+    mGrad: { unit: 'grad', category: 'angle' },
+    mTurn: { unit: 'turn', category: 'angle' },
+    mS: { unit: 's', category: 'time' },
+    mMs: { unit: 'ms', category: 'time' },
+    mHz: { unit: 'hz', category: 'frequency' },
+    mKhz: { unit: 'khz', category: 'frequency' },
+    mDpi: { unit: 'dpi', category: 'resolution' },
+    mDpcm: { unit: 'dpcm', category: 'resolution' },
+    mDppx: { unit: 'dppx', category: 'resolution' },
+    mFr: { unit: 'fr', category: 'flex' },
+};

package/dist/examples/src/units/absolute.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mPt = exports.mPc = exports.mIn = exports.mQ = exports.mMm = exports.mCm = exports.mPx = void 0;
+const core_1 = require("../core");
+exports.mPx = (0, core_1.makeUnitHelperFromDefinition)('mPx');
+exports.mCm = (0, core_1.makeUnitHelperFromDefinition)('mCm');
+exports.mMm = (0, core_1.makeUnitHelperFromDefinition)('mMm');
+exports.mQ = (0, core_1.makeUnitHelperFromDefinition)('mQ');
+exports.mIn = (0, core_1.makeUnitHelperFromDefinition)('mIn');
+exports.mPc = (0, core_1.makeUnitHelperFromDefinition)('mPc');
+exports.mPt = (0, core_1.makeUnitHelperFromDefinition)('mPt');

package/dist/examples/src/units/angle.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mTurn = exports.mGrad = exports.mRad = exports.mDeg = void 0;
+const core_1 = require("../core");
+exports.mDeg = (0, core_1.makeUnitHelperFromDefinition)('mDeg');
+exports.mRad = (0, core_1.makeUnitHelperFromDefinition)('mRad');
+exports.mGrad = (0, core_1.makeUnitHelperFromDefinition)('mGrad');
+exports.mTurn = (0, core_1.makeUnitHelperFromDefinition)('mTurn');

package/dist/examples/src/units/container.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mCqmax = exports.mCqmin = exports.mCqb = exports.mCqi = exports.mCqh = exports.mCqw = void 0;
+const core_1 = require("../core");
+exports.mCqw = (0, core_1.makeUnitHelperFromDefinition)('mCqw');
+exports.mCqh = (0, core_1.makeUnitHelperFromDefinition)('mCqh');
+exports.mCqi = (0, core_1.makeUnitHelperFromDefinition)('mCqi');
+exports.mCqb = (0, core_1.makeUnitHelperFromDefinition)('mCqb');
+exports.mCqmin = (0, core_1.makeUnitHelperFromDefinition)('mCqmin');
+exports.mCqmax = (0, core_1.makeUnitHelperFromDefinition)('mCqmax');

package/dist/examples/src/units/font-relative.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mRlh = exports.mLh = exports.mRic = exports.mIc = exports.mRcap = exports.mCap = exports.mRch = exports.mCh = exports.mRex = exports.mEx = exports.mRem = exports.mEm = void 0;
+const core_1 = require("../core");
+exports.mEm = (0, core_1.makeUnitHelperFromDefinition)('mEm');
+exports.mRem = (0, core_1.makeUnitHelperFromDefinition)('mRem');
+exports.mEx = (0, core_1.makeUnitHelperFromDefinition)('mEx');
+exports.mRex = (0, core_1.makeUnitHelperFromDefinition)('mRex');
+exports.mCh = (0, core_1.makeUnitHelperFromDefinition)('mCh');
+exports.mRch = (0, core_1.makeUnitHelperFromDefinition)('mRch');
+exports.mCap = (0, core_1.makeUnitHelperFromDefinition)('mCap');
+exports.mRcap = (0, core_1.makeUnitHelperFromDefinition)('mRcap');
+exports.mIc = (0, core_1.makeUnitHelperFromDefinition)('mIc');
+exports.mRic = (0, core_1.makeUnitHelperFromDefinition)('mRic');
+exports.mLh = (0, core_1.makeUnitHelperFromDefinition)('mLh');
+exports.mRlh = (0, core_1.makeUnitHelperFromDefinition)('mRlh');

package/dist/examples/src/units/frequency.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mKhz = exports.mHz = void 0;
+const core_1 = require("../core");
+exports.mHz = (0, core_1.makeUnitHelperFromDefinition)('mHz');
+exports.mKhz = (0, core_1.makeUnitHelperFromDefinition)('mKhz');

package/dist/examples/src/units/grid.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mFr = void 0;
+const core_1 = require("../core");
+exports.mFr = (0, core_1.makeUnitHelperFromDefinition)('mFr');

package/dist/examples/src/units/percent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPercentMeasurement = exports.isPercentMeasurement = exports.mPercent = void 0;
+const core_1 = require("../core");
+exports.mPercent = (0, core_1.makeUnitHelperFromDefinition)('mPercent');
+exports.isPercentMeasurement = (0, core_1.makeUnitGuard)(exports.mPercent);
+exports.assertPercentMeasurement = (0, core_1.makeUnitAssert)(exports.mPercent);

package/dist/examples/src/units/resolution.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mDppx = exports.mDpcm = exports.mDpi = void 0;
+const core_1 = require("../core");
+exports.mDpi = (0, core_1.makeUnitHelperFromDefinition)('mDpi');
+exports.mDpcm = (0, core_1.makeUnitHelperFromDefinition)('mDpcm');
+exports.mDppx = (0, core_1.makeUnitHelperFromDefinition)('mDppx');

package/dist/examples/src/units/time.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mMs = exports.mS = void 0;
+const core_1 = require("../core");
+exports.mS = (0, core_1.makeUnitHelperFromDefinition)('mS');
+exports.mMs = (0, core_1.makeUnitHelperFromDefinition)('mMs');