css-calipers 0.0.0 → 0.3.0

package/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Stephane Lafleche
+Copyright (c) 2025 slafleche
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,298 @@
+# CSS-Calipers
+
+**CSS is code. Measure it like one.**  
+Compile-time unit safety for numeric, unit-bearing CSS values, no surprises at runtime.
+
+CSS-Calipers is a tiny layer for typed CSS measurements. Stop parsing CSS
+strings and concatenating units. Do your math on real numbers, get
+compile-time unit safety, and output CSS only at the edges.
+
+At a glance:
+
+- Create measurements with `m` from a number and a unit (defaults to `px`).
+- Do unit-safe math with methods like `add` and `multiply`, then call `.css()`
+  at the edge to get a CSS string (for example "10px").
+
+## Install
+
+```bash
+npm install css-calipers
+```
+
+### Status & support
+
+> 🚧 Work in progress.  
+> API surface and docs may change between `0.x` releases until the first stable version.
+
+- Status: early `0.x` release. Backwards compatibility is not guaranteed until `1.0.0`.
+- Questions or bugs: open an issue on GitHub (see the repository link at the top of this page or in `package.json`).
+- Tooling: tested primarily with TypeScript 5.6+ on Node 18+.
+
+---
+
+## Quick start
+
+```ts
+import { m } from "css-calipers";
+
+// Declare vars
+const paddingBase = m(4); // defaults to "px" with no unit specified
+const rotation = m(45, "deg"); // equivalent to a dedicated helper like mDeg(45)
+
+// Do safe arithmetic
+const margins = paddingBase.add(4);
+const offset = paddingBase.add(margins).multiply(2).subtract(1);
+
+// Emit only at the end in CSS (at runtime or in a build step)
+const style = {
+  padding: paddingBase.css(),
+  transform: `rotate(${rotation.double().css()})`, // 90deg
+};
+```
+
+---
+
+## Features
+
+- **Compile-time unit validation.** Prevents mixing incompatible units.
+- **Arithmetic safety.** Operate only within matching units; explicit when
+  converting.
+- **Explicit emission.** `.css()` outputs a typed string literal only when
+  needed.
+- **Light runtime footprint.** Near-zero cost when emitted at build time.
+- **Framework-agnostic.** Works anywhere TypeScript does.
+
+Any numeric, unit-bearing CSS value is supported: `m` accepts any unit string you’d use in CSS
+(`'px'`, `'rem'`, `'%'`, `'vw'`, `'deg'`, `'ms'`, …), and you can model new
+measurements without waiting for a dedicated helper. For convenience and better
+types, every standard CSS unit also has a named helper (for example
+`mPx`, `mPercent`, `mVw`, `mEm`, `mMs`, `mFr`), which are equivalent to calling
+`m(value, 'unit')` directly.
+
+CSS-Calipers focuses exclusively on numeric, unit-bearing CSS values. Keywords
+like `auto`, `fit-content`, or `max-content`, full shorthand strings,
+`var(--token)`, or `calc(...)` expressions should remain explicit strings or
+dedicated keyword types in your app or styling layer. Everything else stays as
+plain CSS (see "Philosophy & Boundaries" below for more detail).
+
+---
+
+## Should I use this?
+
+CSS-Calipers is a good fit if:
+
+- You already use TypeScript (or plan to) and want compile-time guarantees around CSS units.
+- You have a design system or token layer where layout math and unit conversions matter.
+- You care about catching unit mismatches and layout invariants early, in dev or tests.
+
+It’s probably overkill if:
+
+- Your project has minimal custom layout math or relies mostly on utility classes/framework CSS.
+- You don’t use TypeScript and aren’t looking for stronger typing around CSS values.
+- You’re comfortable relying on manual discipline instead of typed measurements for units.
+
+---
+
+### Layout tokens example
+
+```ts
+import { m, mPercent, mVw, mVh, mFr, assertCondition } from "css-calipers";
+
+// Token-style measurements (px by default)
+const spacing = m(8); // Defaults to px; equivalent to mPx(8)
+const cardPadding = spacing.multiply(2); // 16px
+const gutter = spacing.multiply(1.5); // 12px
+
+// Responsive bounds expressed in other units
+const minWidthPercent = mPercent(75); // 75%; same as m(75, "%")
+const maxWidthViewport = mVw(100); // 100vw; same as m(100, "vw")
+
+// Derived content width in px
+const contentBase = m(320);
+const minCardWidth = m(260);
+const maxCardWidth = m(360);
+
+// In real code, these bounds typically come from tokens or configuration,
+// so keeping the clamp in measurement space ensures units stay consistent.
+const cardWidth = contentBase.clamp(minCardWidth, maxCardWidth);
+
+// Unitless ratio you can reuse elsewhere
+const ratio = contentBase.getValue() / spacing.getValue(); // returns a number, no unit
+
+// Apply ratio to a different unit family
+const heroHeight = mVh(40).multiply(ratio);
+
+// Invalid arithmetic (different units) fails at compile time
+const exampleError = cardWidth.add(heroHeight); // ❌ Type error (px vs vh) see error handling below
+
+// Use plain numbers where they are just counts
+const columns = 3;
+
+// In development, enforce simple invariants so layout mistakes fail fast.
+// In production, you can either rely on earlier validation or add a separate
+// fallback path if this invariant is ever broken.
+if (process.env.NODE_ENV !== "production") {
+  assertCondition(
+    () => columns > 0,
+    "cardGridStyles: columns must be greater than zero"
+  );
+}
+
+// Compose a simple grid layout
+const cardGridStyles = {
+  display: "grid",
+  gap: gutter.css(),
+  gridTemplateColumns: `repeat(${columns}, ${mFr(1).css()})`,
+  // width driven by card width + gutters
+  width: cardWidth
+    .multiply(columns)
+    .add(gutter.multiply(columns - 1))
+    .css(),
+  // container bounds in percent/viewport units
+  minWidth: minWidthPercent.css(),
+  maxWidth: maxWidthViewport.css(),
+  // derived hero height based on px ratio, expressed in vh and used inside a calc() string
+  // calc() stays plain CSS; css-calipers only provides the numeric pieces
+  minHeight: `calc(${heroHeight.css()} + 10vh)`,
+};
+```
+
+---
+
+## Do custom checks your way
+
+CSS-Calipers will happily enforce units anywhere you choose, but it stays
+unopinionated about where those guards live. Drop assertions in a component, in
+a theme overwrite, hardcode a debug routine, or wire a global invariant; the
+structure is up to you:
+
+```ts
+import { assertMatchingUnits } from "css-calipers";
+import { formTokens } from "@/tokens/forms.tokens";
+
+if (process.env.NODE_ENV !== "production") {
+  assertMatchingUnits(
+    formTokens.field.paddingBlock,
+    formTokens.field.paddingInline,
+    "Form control padding mismatch"
+  );
+}
+```
+
+You can apply the same checks globally (e.g., during app bootstrap) or only
+inside the components that need them. CSS-Calipers gives you the tools;
+placement is a design decision.
+
+---
+
+## Error behavior
+
+- Operations are fail-fast: when you call helpers like `add`, `divide`, `clamp`,
+  `measurementMin` / `measurementMax`, or the assertion helpers with invalid
+  input (for example, mismatched units or non-finite values), css-calipers
+  throws a normal `Error`.
+- Error messages include the operation name (for example,
+  `css-calipers.Measurement.divide` or `css-calipers.assertMatchingUnits`), the
+  relevant values/units, and any context string you pass in.
+- The library does not catch these errors for you. You choose where to place
+  assertions and where (if anywhere) to catch and handle exceptions.
+- In production, a common pattern is to wrap assertions in dev-only guards
+  (such as `if (process.env.NODE_ENV !== 'production')`) or to enforce
+  invariants in tests, so checks stay cheap and predictable at runtime.
+
+---
+
+## Co-existing with other systems
+
+You don’t have to convert everything at once, or at all. If it fits your setup, you can write small adapters that accept existing CSS strings, css-calipers measurements, or plain numbers and turn them into CSS values. The example below is just one possible adapter pattern, not a recommendation or default.
+
+```ts
+import { m, isMeasurement } from "css-calipers";
+
+type SpacingInput = string | number | ReturnType<typeof m>;
+
+const toSpacingCss = (value: SpacingInput): string => {
+  if (typeof value === "string") {
+    // Already a CSS value (for example, "auto" or "var(--gap)")
+    return value;
+  }
+
+  const measurement = isMeasurement(value) ? value : m(value);
+  return measurement.css();
+};
+
+// Later, callers can pass tokens, raw CSS strings, or measurements:
+toSpacingCss("var(--card-gap)");
+toSpacingCss(8); // becomes "8px"
+toSpacingCss(m(12, "px"));
+```
+
+---
+
+## Advanced
+
+### String Literal Type Exclusion
+
+When helpers must _exclude_ CSS-Calipers–emitted numeric, unit-bearing CSS values from a keyword union,
+use the exported `MeasurementString` type together with your existing CSS
+property typings (for example, the `Property` types from the `csstype`
+package):
+
+```ts
+import type { MeasurementString } from "css-calipers";
+import type { Property } from "csstype";
+
+type SpacingKeyword = Exclude<
+  Extract<Property.Margin, string>,
+  MeasurementString
+>;
+```
+
+This lets helpers stay strict: `IMeasurement` for numeric, unit-bearing CSS values; targeted string
+keywords for symbolic CSS values, without reintroducing vague unions like
+`MeasurementLike`.
+
+### Integration Patterns
+
+- **Typed helpers:** Accept either `IMeasurement` or a constrained keyword type,
+  never a generic string.
+- **Pre-emission transforms:** Compose all math in CSS-Calipers, emit once at
+  the style boundary.
+- **Build-time pipelines:** Run measurement math in Node or a build step
+  (scripts, codegen, or bundler plugins) and emit plain CSS or tokens for your
+  existing styling system so runtime only sees static values.
+- **Unit guards in debug:** Use `assertUnit()` in dev-only blocks to confirm
+  consistency between related measurements.
+- **CSS variables:** Pass CSS-Calipers `.css()` output into style layers that
+  interpolate them, but don’t try to store `var(--token)` inside the library.
+
+---
+
+## Philosophy & Boundaries
+
+- **Measurement math lives here; string composition lives elsewhere.**  
+  Use CSS-Calipers for unit-aware calculations, then hand results to
+  helpers/adapters that emit CSS literals. Keep `calc()`/`clamp()` logic outside
+  the library so measurement objects remain pure.
+
+- **`.css()` at runtime is an edge, not a habit.**  
+  You can call `.css()` at runtime, but prefer emitting once to avoid hot-path
+  string churn.
+
+- **Numbers are operands, not CSS-Calipers values.**  
+  You cannot create a CSS-Calipers value without a unit. Pass plain numbers as
+  operands (`add`, `subtract`, `multiply`, `divide`) or combine with another
+  `IMeasurement`, but never store bare numbers inside library state. If a value
+  lacks both number and unit, CSS-Calipers won’t track it; you own whatever
+  logic wraps it.
+
+- **Model keywords explicitly (not “escape hatches”).**  
+  If a helper needs symbolic CSS (e.g., `'auto'`, `'fit-content'`), define a
+  precise keyword type and purposely exclude the emitted string type from
+  CSS-Calipers so numeric, unit-bearing CSS values remain the default path.
+
+- **CSS custom properties coexist; they don’t mix.**  
+  Third-party primitives exposing `var(--token)` should keep those values as raw
+  CSS strings. Feed CSS-Calipers `.css()` output into them where possible, but
+  don’t wrap CSS variables inside the library; treat them as parallel pipes
+  that meet in the style layer.

package/RELEASING.md

@@ -0,0 +1,62 @@
+# Releasing css-calipers
+
+This document describes how to publish a new version of `css-calipers` to npm
+using the local release script.
+
+## Prerequisites
+
+- You have push access to the `main` branch of the repository.
+- You are logged in to npm with an account that can publish the
+  `css-calipers` package (`npm whoami` should work).
+- If your npm account uses 2FA, be ready to enter your OTP during
+  `npm publish`.
+- The supported runtime target for published builds is Node 18 or newer.
+
+## Release flow (local, scripted)
+
+Releases should be performed via the `release` script rather than calling
+`npm publish` directly.
+
+1. Ensure your local `main` branch is up to date.
+2. From the project root, run `npm run release`.
+
+3. The script will:
+   - Verify that the current branch is `main` (abort otherwise).
+   - Warn if there are uncommitted changes and ask whether to continue.
+   - Run the core tests (`npm run test:core`).
+   - Run the build (`npm run build`) to produce `dist/cjs` and `dist/esm`.
+   - Check that the expected build outputs exist.
+   - Run the dist tests (`npm run test:dist`) against both CJS and ESM outputs.
+   - Run the type tests (`npm run test:types`).
+   - Prompt you to choose the version bump (`patch`, `minor`, or `major`).
+   - Run `npm version <type>` to bump the version and create a tag.
+   - Show the new version and ask for final confirmation before publishing.
+   - On confirmation, run `npm publish` (with a special environment variable
+     set), which also triggers the `prepublishOnly` hook and publishes under
+     the default `latest` dist-tag.
+
+If any step fails (tests, build, or publish), the script will exit with a
+non-zero status and print an error message.
+
+## prepublishOnly safety net
+
+The `prepublishOnly` npm script is configured to refuse direct `npm publish`
+unless the `CSS_CALIPERS_RELEASE` environment variable is set. It does not
+re-run tests or builds; those are handled by the release script.
+
+The `prepublishOnly` hook runs automatically on every `npm publish` and will
+block publishing if the environment guard fails.
+
+## Dist-tag strategy
+
+- All releases are currently published with npm’s default `latest` dist-tag.
+- There is no separate `next`/`beta` channel yet; if that changes, both this
+  document and the release script should be updated to reflect the new
+  tagging behavior.
+
+## Notes and future improvements
+
+- Direct `npm publish` is discouraged; prefer `npm run release` so all checks
+  run consistently.
+- In the future, publishing can be moved to CI (for example, from tags on
+  `main`) without changing the core expectations described here.

package/dist/cjs/core.js

@@ -0,0 +1,279 @@
+"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.m = exports.isMeasurement = void 0;
+exports.assertMatchingUnits = assertMatchingUnits;
+const unitDefinitions_1 = require("./unitDefinitions");
+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;
+const m = (value, unit = 'px') => createMeasurement(value, unit.toLowerCase());
+exports.m = m;
+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;

package/dist/cjs/index.js

@@ -0,0 +1,30 @@
+"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("./core"), exports);
+__exportStar(require("./units/percent"), exports);
+__exportStar(require("./units/absolute"), exports);
+__exportStar(require("./units/font-relative"), exports);
+__exportStar(require("./units/viewport"), exports);
+__exportStar(require("./units/viewport-small"), exports);
+__exportStar(require("./units/viewport-large"), exports);
+__exportStar(require("./units/viewport-dynamic"), exports);
+__exportStar(require("./units/container"), exports);
+__exportStar(require("./units/angle"), exports);
+__exportStar(require("./units/time"), exports);
+__exportStar(require("./units/frequency"), exports);
+__exportStar(require("./units/resolution"), exports);
+__exportStar(require("./units/grid"), exports);