css-calipers 0.9.2 → 0.9.4

package/dist/esm/fraction.js

@@ -0,0 +1,129 @@
+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;
+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();
+export function r(numeratorOrDenominator, denominator) {
+    const numerator = denominator === undefined ? numeratorOrDenominator : numeratorOrDenominator;
+    const resolvedDenominator = denominator === undefined ? 1 : denominator;
+    return new FractionImpl(numerator, resolvedDenominator);
+}
+export 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");
+};
+export const parseRatio = (value) => {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? { numerator: value, denominator: 1 } : null;
+    }
+    if (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;
+};
+export 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);
+};
+export const reduceFraction = (fraction) => normalizeFraction(fraction);
+export const simplifyFraction = (fraction) => {
+    const reduced = normalizeFraction(fraction);
+    return new FractionImpl(reduced.numerator(), reduced.denominator(), { omitDenominatorWhenOne: true });
+};
+export const fractionToFloat = (fraction) => fraction.numerator() / fraction.denominator();

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

@@ -0,0 +1,12 @@
+import type { ErrorCode } from './errors';
+export type MeasurementCreationErrorPayload = {
+    message: string;
+    context?: string;
+    details: {
+        code: ErrorCode;
+        helper: string;
+        inputSummary: string;
+    };
+};
+export declare const buildMeasurementCreationError: (value: number, unit: string, helper: string, context?: string) => MeasurementCreationErrorPayload;
+//# sourceMappingURL=buildMeasurementCreationError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildMeasurementCreationError.d.ts","sourceRoot":"","sources":["../../../src/internal/buildMeasurementCreationError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,MAAM,+BAA+B,GAAG;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE;QACP,IAAI,EAAE,SAAS,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,OAAO,MAAM,EACb,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,UAAU,MAAM,KACf,+BAWF,CAAC"}

package/dist/esm/internal/buildMeasurementCreationError.js

@@ -0,0 +1,12 @@
+export 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}`,
+        },
+    };
+};

package/dist/esm/internal/buildMeasurementCreationError.tests.d.ts

@@ -0,0 +1,3 @@
+export { buildMeasurementCreationError } from './buildMeasurementCreationError';
+export type { MeasurementCreationErrorPayload } from './buildMeasurementCreationError';
+//# sourceMappingURL=buildMeasurementCreationError.tests.d.ts.map

package/dist/esm/internal/buildMeasurementCreationError.tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildMeasurementCreationError.tests.d.ts","sourceRoot":"","sources":["../../../src/internal/buildMeasurementCreationError.tests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,YAAY,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/esm/internal/buildMeasurementCreationError.tests.js

@@ -0,0 +1 @@
+export { buildMeasurementCreationError } from './buildMeasurementCreationError';

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

@@ -0,0 +1,34 @@
+import type { CoreApi } from "./createCoreApi";
+import type { ContainerQueryBuilderHelpers } from "../containerQueries/helpers";
+import type { StyleRule } from "../mediaQueries/types";
+import { type IContainerQueries, type IContainerQueryProps, type IContainerQueryStyles } from "../containerQueries/containerQueries";
+import { type IContainerQueryAspectRatio, type IContainerQueryBlock, type IContainerQueryCustomFeatures, type IContainerQueryInline, type IContainerQueryStyle } from "../containerQueries/modules";
+import { type ContainerQueryFactoryConfig } from "../containerQueries/factory";
+import type { ContainerQueryModulesList } from "../containerQueries/moduleRegistry";
+type ContainerQueriesCore = Pick<CoreApi, "assertCondition" | "assertMatchingUnits">;
+export declare const createContainerQueriesApi: (core: ContainerQueriesCore) => {
+    readonly buildContainerQueryString: (config: IContainerQueryProps) => string;
+    readonly makeContainerQueryStyle: <T extends IContainerQueries>(queries: T) => (stylesByQuery: IContainerQueryStyles<T>) => StyleRule;
+    readonly containerQueryFactory: <TModules extends ContainerQueryModulesList | undefined, TQueries extends import("../containerQueries").CSSContainerQueries, TOutput = import("../mediaQueries/types").ComplexStyleRule>(options: {
+        queries: TQueries;
+        config: ContainerQueryFactoryConfig<TModules, TOutput>;
+    }) => (stylesByQuery: Partial<Record<keyof TQueries, StyleRule>>) => TOutput;
+    readonly emitCoreFeatures: (props: import("../containerQueries/containerQueries").IContainerQueryCore, helpers: ContainerQueryBuilderHelpers) => void;
+    readonly emitAspectRatioFeatures: (props: IContainerQueryAspectRatio, helpers: ContainerQueryBuilderHelpers, validate?: import("../containerQueries/modules").ContainerQueryAspectRatioValidator) => void;
+    readonly emitBlockSizeFeatures: (props: IContainerQueryBlock, helpers: ContainerQueryBuilderHelpers, validate?: import("../containerQueries/modules").ContainerQueryBlockValidator) => void;
+    readonly emitInlineSizeFeatures: (props: IContainerQueryInline, helpers: ContainerQueryBuilderHelpers, validate?: import("../containerQueries/modules").ContainerQueryInlineValidator) => void;
+    readonly emitStyleFeatures: (props: IContainerQueryStyle, helpers: ContainerQueryBuilderHelpers, validate?: import("../containerQueries/modules").ContainerQueryStyleValidator) => void;
+    readonly emitCustomFeatures: (props: IContainerQueryCustomFeatures, helpers: ContainerQueryBuilderHelpers, options?: {
+        allowQueryArrays?: boolean;
+    }, validate?: import("../containerQueries/modules").ContainerQueryCustomFeaturesValidator) => void;
+    readonly containerQueryOutputVanillaExtract: (container: import("../mediaQueries/types").ComplexStyleRule) => Record<string, unknown>;
+    readonly createContainerQueryBuilder: <TConfig>(options: {
+        emitBase: import("../containerQueries/helpers").ContainerQueryExtensionHandler<TConfig>;
+        emitExtensions?: import("../containerQueries/helpers").ContainerQueryExtensionHandler<TConfig> | undefined;
+        resolveType?: ((config: TConfig) => "all" | "print" | "screen" | undefined) | undefined;
+        config?: import("../containerQueries/helpers").ContainerQueryBuilderConfig;
+    }) => (config: TConfig) => string;
+};
+export type ContainerQueriesApi = ReturnType<typeof createContainerQueriesApi>;
+export type { IContainerQueries, IContainerQueryProps, IContainerQueryStyles, IContainerQueryCustomFeatures, IContainerQueryAspectRatio, IContainerQueryBlock, IContainerQueryInline, IContainerQueryStyle, ContainerQueryFactoryConfig, ContainerQueryModulesList, };
+//# sourceMappingURL=createComponentQueriesApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createComponentQueriesApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createComponentQueriesApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAML,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAEpF,KAAK,oBAAoB,GAAG,IAAI,CAC9B,OAAO,EACP,iBAAiB,GAAG,qBAAqB,CAC1C,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,MAAM,oBAAoB;;uCAyB/D,CAAC,SAAS,iBAAiB,WAAW,CAAC,MACvC,eAAe,qBAAqB,CAAC,CAAC,CAAC,KAAG,SAAS;;;;WA8CyiC,yDAA+C;;;;;;;wBAhFjnC,CAAC;;;;;;;;WAgFm5B,eAAe;CAfj8B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC/E,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,EAC7B,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,2BAA2B,EAC3B,yBAAyB,GAC1B,CAAC"}

package/dist/esm/internal/createComponentQueriesApi.js

@@ -0,0 +1,52 @@
+import { createContainerQueryBuilder } from "../containerQueries/helpers";
+import { createContainerQueryValidation } from "../containerQueries/validation";
+import { createEmitCoreFeatures, } from "../containerQueries/containerQueries";
+import { emitAspectRatioFeatures, emitBlockSizeFeatures, emitCustomFeatures, emitInlineSizeFeatures, emitStyleFeatures, } from "../containerQueries/modules";
+import { createContainerQueryFactory, } from "../containerQueries/factory";
+import { containerQueryOutputVanillaExtract } from "../libraryHelpers/vanilla-extract";
+export const createContainerQueriesApi = (core) => {
+    const validation = createContainerQueryValidation({
+        assertCondition: core.assertCondition,
+        assertMatchingUnits: core.assertMatchingUnits,
+    });
+    const emitCoreFeatures = createEmitCoreFeatures(validation);
+    const emitBaseFeatures = (props, helpers) => {
+        emitCoreFeatures(props, helpers);
+        emitAspectRatioFeatures(props, helpers);
+        emitBlockSizeFeatures(props, helpers);
+        emitInlineSizeFeatures(props, helpers);
+        emitStyleFeatures(props, helpers);
+        emitCustomFeatures(props, helpers);
+    };
+    const buildContainerQueryString = 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 = createContainerQueryFactory();
+    return {
+        buildContainerQueryString,
+        makeContainerQueryStyle,
+        containerQueryFactory,
+        emitCoreFeatures,
+        emitAspectRatioFeatures,
+        emitBlockSizeFeatures,
+        emitInlineSizeFeatures,
+        emitStyleFeatures,
+        emitCustomFeatures,
+        containerQueryOutputVanillaExtract,
+        createContainerQueryBuilder,
+    };
+};

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

@@ -0,0 +1,289 @@
+import { type UnitDefinitionRecord, type UnitHelperName } from '../unitDefinitions';
+import { type ErrorConfigStore } from './errors';
+import type { BrandedMeasurement, IMeasurement, UnitAssertion, UnitGuard, UnitHelper } from '../core';
+type MeasurementCreateOptions<Unit extends string> = {
+    unit?: Unit;
+    context?: string;
+};
+export declare const createCoreApi: (errorStore: ErrorConfigStore) => {
+    readonly m: {
+        (value: number): BrandedMeasurement<"px">;
+        (value: number, options: {
+            context?: string;
+        }): BrandedMeasurement<"px">;
+        <Unit extends string>(value: number, unit: Unit, context?: string): IMeasurement<Lowercase<Unit>> & {
+            readonly __unitBrand: Lowercase<Unit>;
+        };
+        <Unit extends string>(value: number, options: MeasurementCreateOptions<Unit>): IMeasurement<Lowercase<Unit>> & {
+            readonly __unitBrand: Lowercase<Unit>;
+        };
+    };
+    readonly isMeasurement: (x: unknown) => x is IMeasurement<string>;
+    readonly assertMatchingUnits: <Unit extends string>(left: IMeasurement<Unit>, right: IMeasurement<Unit>, context: string) => void;
+    readonly measurementMin: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>;
+    readonly measurementMax: <Unit extends string>(a: IMeasurement<Unit>, b: IMeasurement<Unit>) => IMeasurement<Unit>;
+    readonly measurementUnitMetadata: {
+        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";
+        };
+    };
+    readonly makeUnitHelper: <Unit extends string>(unit: Unit) => UnitHelper<Unit>;
+    readonly makeUnitHelperFromDefinition: <Name extends UnitHelperName>(name: Name) => UnitHelper<UnitDefinitionRecord[Name]["unit"]>;
+    readonly makeUnitGuard: <T extends UnitHelper>(helper: T) => UnitGuard<T>;
+    readonly makeUnitAssert: <T extends UnitHelper>(helper: T) => UnitAssertion<T>;
+    readonly hasCssMethod: (x: unknown) => x is {
+        css: () => string;
+    };
+    readonly assertUnit: <Unit extends string>(measurement: IMeasurement<Unit>, expectedUnit: string, context?: string) => void;
+    readonly assertCondition: (condition: boolean | (() => boolean), message: string) => void;
+    readonly getErrorConfig: () => Required<import("./errors").ErrorConfig>;
+    readonly setErrorConfig: (next: import("./errors").ErrorConfig) => void;
+};
+export type CoreApi = ReturnType<typeof createCoreApi>;
+export {};
+//# sourceMappingURL=createCoreApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCoreApi.d.ts","sourceRoot":"","sources":["../../../src/internal/createCoreApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,SAAS,EACT,UAAU,EACX,MAAM,SAAS,CAAC;AAGjB,KAAK,wBAAwB,CAAC,IAAI,SAAS,MAAM,IAAI;IACnD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,YAAY,gBAAgB;;gBAqRtC,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC;gBAE1C,MAAM,WACJ;YAAE,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,GAC5B,kBAAkB,CAAC,IAAI,CAAC;SAChB,IAAI,SAAS,MAAM,SACrB,MAAM,QACP,IAAI,YACA,MAAM,GACf,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG;YACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACvC;SACU,IAAI,SAAS,MAAM,SACrB,MAAM,WACJ,wBAAwB,CAAC,IAAI,CAAC,GACtC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG;YACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACvC;;gCApBI,OAAO,KACT,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC;mCA/QC,IAAI,SAAS,MAAM,QACxC,YAAY,CAAC,IAAI,CAAC,SACjB,YAAY,CAAC,IAAI,CAAC,WAChB,MAAM,KACd,IAAI;8BA6ZiB,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,IAAI,CAAC,KACpB,YAAY,CAAC,IAAI,CAAC;8BAKG,IAAI,SAAS,MAAM,KACtC,YAAY,CAAC,IAAI,CAAC,KAClB,YAAY,CAAC,IAAI,CAAC,KACpB,YAAY,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAlEG,IAAI,SAAS,MAAM,QACnC,IAAI,KACT,UAAU,CAAC,IAAI,CAAC;4CAImB,IAAI,SAAS,cAAc,QACzD,IAAI,KACT,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;6BAS1B,CAAC,SAAS,UAAU,UACjC,CAAC,KACR,SAAS,CAAC,CAAC,CAAC;8BAKS,CAAC,SAAS,UAAU,UAClC,CAAC,KACR,aAAa,CAAC,CAAC,CAAC;+BAmBd,OAAO,KACT,CAAC,IAAI;QAAE,GAAG,EAAE,MAAM,MAAM,CAAA;KAAE;0BAyBT,IAAI,SAAS,MAAM,eACxB,YAAY,CAAC,IAAI,CAAC,gBACjB,MAAM,YACV,MAAM;0CAIL,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,WAC3B,MAAM,KACd,IAAI;;;CA8BR,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}