css-calipers 0.0.0 → 0.4.0

package/dist/esm/core.js

@@ -0,0 +1,264 @@
+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;
+import { UNIT_DEFINITIONS, } from './unitDefinitions';
+import { throwHelperError, throwMeasurementMethodError, } from './internal/errors';
+export function 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,
+        });
+    }
+}
+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}`,
+            });
+        }
+        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,
+            });
+        }
+    }
+    assert(predicate, message) {
+        if (!predicate(this)) {
+            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) {
+            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)) {
+            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)) {
+            throwMeasurementMethodError({
+                operation: 'css-calipers.Measurement.clamp',
+                caller: this,
+                params: [min, max],
+                message: 'clamp: expected finite 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()})`,
+            });
+        }
+        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);
+export const isMeasurement = (x) => x instanceof Measurement;
+export const m = (value, unit = 'px') => createMeasurement(value, unit.toLowerCase());
+export const makeUnitHelper = (unit) => {
+    const normalizedUnit = unit.toLowerCase();
+    const factory = (value) => createMeasurement(value, normalizedUnit);
+    return Object.assign(factory, {
+        unit: normalizedUnit,
+    });
+};
+export const makeUnitHelperFromDefinition = (name) => makeUnitHelper(UNIT_DEFINITIONS[name].unit);
+export const measurementUnitMetadata = UNIT_DEFINITIONS;
+export const makeUnitGuard = (helper) => {
+    return (value) => isMeasurement(value) && value.isUnit(helper.unit);
+};
+export 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,
+            });
+        }
+    };
+};
+export const hasCssMethod = (x) => {
+    return (typeof x === 'object' &&
+        x !== null &&
+        'css' in x &&
+        typeof x.css === 'function');
+};
+export const measurementMin = (a, b) => {
+    assertMatchingUnits(a, b, 'measurementMin');
+    return a.getValue() <= b.getValue() ? a : b;
+};
+export const measurementMax = (a, b) => {
+    assertMatchingUnits(a, b, 'measurementMax');
+    return a.getValue() >= b.getValue() ? a : b;
+};
+export const assertUnit = (measurement, expectedUnit, context) => measurement.assertUnit(expectedUnit, context);
+export const assertCondition = (condition, message) => {
+    const passed = typeof condition === 'function' ? condition() : condition;
+    if (!passed) {
+        throwHelperError({
+            operation: 'css-calipers.assertCondition',
+            params: [],
+            message,
+        });
+    }
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,15 @@
+export * from './core';
+export * from './units/percent';
+export * from './units/absolute';
+export * from './units/font-relative';
+export * from './units/viewport';
+export * from './units/viewport-small';
+export * from './units/viewport-large';
+export * from './units/viewport-dynamic';
+export * from './units/container';
+export * from './units/angle';
+export * from './units/time';
+export * from './units/frequency';
+export * from './units/resolution';
+export * from './units/grid';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AAEvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,14 @@
+export * from './core';
+export * from './units/percent';
+export * from './units/absolute';
+export * from './units/font-relative';
+export * from './units/viewport';
+export * from './units/viewport-small';
+export * from './units/viewport-large';
+export * from './units/viewport-dynamic';
+export * from './units/container';
+export * from './units/angle';
+export * from './units/time';
+export * from './units/frequency';
+export * from './units/resolution';
+export * from './units/grid';

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

@@ -0,0 +1,28 @@
+import type { IMeasurement } from "../core";
+export interface MeasurementMethodErrorContext {
+    /** Operation name (for example, "add", "divide", "clamp"). */
+    operation: string;
+    /** Receiver of the method call. */
+    caller: IMeasurement<string>;
+    /** Other measurements involved (for example, delta, min, max). */
+    params: IMeasurement<string>[];
+    /** Core human-readable description of what went wrong. */
+    message: string;
+    /** Optional caller-supplied context prefix. */
+    context?: string;
+}
+export interface HelperErrorContext {
+    /** Operation name (for example, "assertMatchingUnits"). */
+    operation: string;
+    /** Measurements involved in the helper call (for example, left/right, min/max). */
+    params: IMeasurement<string>[];
+    /** Core human-readable description of what went wrong. */
+    message: string;
+    /** Optional caller-supplied context prefix. */
+    context?: string;
+}
+/** Throw an Error for a Measurement instance method using a structured context. */
+export declare const throwMeasurementMethodError: (ctx: MeasurementMethodErrorContext) => never;
+/** Throw an Error for a helper/free function using a structured context. */
+export declare const throwHelperError: (ctx: HelperErrorContext) => never;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,WAAW,6BAA6B;IAC5C,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7B,kEAAkE;IAClE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAWD,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,GACtC,KAAK,6BAA6B,KACjC,KAIF,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,GAAI,KAAK,kBAAkB,KAAG,KAI1D,CAAC"}

package/dist/esm/internal/errors.js

@@ -0,0 +1,12 @@
+const formatErrorMessage = (operation, message, context) => {
+    const core = `${operation}: ${message}`;
+    return context ? `${context}: ${core}` : core;
+};
+/** Throw an Error for a Measurement instance method using a structured context. */
+export const throwMeasurementMethodError = (ctx) => {
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context));
+};
+/** Throw an Error for a helper/free function using a structured context. */
+export const throwHelperError = (ctx) => {
+    throw new Error(formatErrorMessage(ctx.operation, ctx.message, ctx.context));
+};

package/dist/esm/unitDefinitions.d.ts

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

package/dist/esm/unitDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unitDefinitions.d.ts","sourceRoot":"","sources":["../../src/unitDefinitions.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GACpB,SAAS,GACT,iBAAiB,GACjB,sBAAsB,GACtB,iBAAiB,GACjB,uBAAuB,GACvB,uBAAuB,GACvB,yBAAyB,GACzB,kBAAkB,GAClB,OAAO,GACP,MAAM,GACN,WAAW,GACX,YAAY,GACZ,MAAM,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EsB,CAAC;AAEpD,MAAM,MAAM,oBAAoB,GAAG,OAAO,gBAAgB,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,MAAM,oBAAoB,CAAC"}

package/dist/esm/unitDefinitions.js

@@ -0,0 +1,64 @@
+export const 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' },
+};