css-calipers 0.15.0 → 1.1.0-beta.0

package/dist/cjs/corpus.js

@@ -0,0 +1,53 @@
+"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 });
+exports.createCalipersBundle = exports.createCalipers = void 0;
+// CORPUS: the css-calipers LAZY-DEFAULTS convenience entry, plus the master factory.
+//
+// - DEFAULT export: `createCalipersBundle`, the calipers MASTER factory. It mirrors the
+//   compendium's `publishCompendium`: one keyed config (a slot per sub-factory) that binds
+//   the whole calipers surface in one object. A bare `createCalipersBundle()` binds it all
+//   at defaults.
+// - NAMED exports: the full default set (`m` / `r` / `i` / `f` / `color`, each a
+//   factory-at-defaults instance) plus the sub-factories (`createCalipers` / `createColor`),
+//   so a consumer who just wants the defaults never has to bind anything.
+//
+// This is the convenience layer ON TOP of the factory, never a replacement: configuration
+// still goes through a factory. (Per-property value helpers are the books layer now, not
+// calipers.) Unlike `./measurements`, this entry is NOT colour-free: it pulls in the colour
+// value primitive (and `culori`) by design.
+const color_1 = require("./color");
+const factory_1 = require("./factory");
+Object.defineProperty(exports, "createCalipers", { enumerable: true, get: function () { return factory_1.createCalipers; } });
+__exportStar(require("./index"), exports);
+/**
+ * The calipers MASTER factory: combine the two sub-factories (`createCalipers` for the
+ * measurement / scalar surface, `createColor` for the colour value) under one keyed config,
+ * returning every helper bound in one object. Mirrors `publishCompendium`. A bare
+ * `createCalipersBundle()` binds everything at defaults; this file DEFAULT-exports it, and
+ * the named re-exports above are the same helpers already bound at defaults.
+ */
+const createCalipersBundle = (config = {}) => {
+    var _a;
+    return ({
+        ...(0, factory_1.createCalipers)(config.measurements),
+        // when no colour config is given, P is the default `readonly []` (no custom formats),
+        // so an empty formats list is the right default; the double cast satisfies the generic.
+        color: (0, color_1.createColor)((_a = config.color) !== null && _a !== void 0 ? _a : { formats: [] }),
+    });
+};
+exports.createCalipersBundle = createCalipersBundle;
+exports.default = exports.createCalipersBundle;

package/dist/cjs/css-values/cssValues.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCssValues = void 0;
+const float_1 = require("../float");
+const integer_1 = require("../integer");
+const spec_1 = require("./spec");
+const clampNumber = (value, min, max) => Math.min(max, Math.max(min, value));
+/**
+ * Build the value object for a number input, constraining it with the row's
+ * primitive (`i()` for `int`, `f()` for `float`). Under `'clamp'`, the number is
+ * first clamped into `[min, max]` (only when both bounds exist); otherwise the
+ * primitive throws on an out-of-range or non-integer value.
+ */
+const buildNumber = (row, value, policy) => {
+    let next = value;
+    if (policy === 'clamp' &&
+        row.min !== undefined &&
+        row.max !== undefined) {
+        next = clampNumber(value, row.min, row.max);
+    }
+    const bounds = { min: row.min, max: row.max, context: row.name };
+    const scalar = row.kind === 'int' ? (0, integer_1.i)(next, bounds) : (0, float_1.f)(next, bounds);
+    // Every `PropertyValueMap[CssProperty]` value type widens to include
+    // `(string & {})`, so the scalar's `string` render is directly assignable; no
+    // cast is needed (and one would be flagged as redundant).
+    return {
+        css: () => scalar.css(),
+        toString: () => scalar.css(),
+        value: () => scalar.value(),
+    };
+};
+/** Build the value object for a keyword input (passed through untouched). */
+const buildKeyword = (keyword) => ({
+    css: () => keyword,
+    toString: () => keyword,
+    value: () => keyword,
+});
+/**
+ * Generate a single property helper from a spec row. Number inputs are
+ * constrained via the row's scalar primitive; keyword inputs (members of the
+ * row's `keywords`) pass through.
+ */
+const makeHelper = (spec, defaultPolicy) => {
+    const keywords = new Set(spec.keywords);
+    return (value, opts) => {
+        var _a;
+        if (typeof value === 'string') {
+            if (!keywords.has(value)) {
+                throw new Error(`${spec.name}: '${value}' is not a valid keyword` +
+                    ` (expected one of: ${spec.keywords.join(', ') || 'none'})`);
+            }
+            return buildKeyword(value);
+        }
+        const policy = (_a = opts === null || opts === void 0 ? void 0 : opts.outOfRange) !== null && _a !== void 0 ? _a : defaultPolicy;
+        return buildNumber(spec, value, policy);
+    };
+};
+/**
+ * Create a set of per-property CSS-value helpers, layered on the scalar
+ * primitives `i()` / `f()`. Each helper constrains its number against the
+ * property's bound and accepts that property's keyword companions, returning a
+ * `.css()`-renderable {@link CssValue} typed against csstype.
+ *
+ * `config.outOfRange` is the instance-wide default for out-of-range numbers
+ * (`'throw'`, the default, or `'clamp'`); a per-call `opts.outOfRange` overrides
+ * it. The package's bare `opacity` / `zIndex` / ... exports are this factory at
+ * its defaults.
+ */
+const createCssValues = (config = {}) => {
+    var _a;
+    const defaultPolicy = (_a = config.outOfRange) !== null && _a !== void 0 ? _a : 'throw';
+    const helpers = {};
+    for (const spec of spec_1.CSS_VALUE_SPEC) {
+        helpers[spec.name] = makeHelper(spec, defaultPolicy);
+    }
+    return helpers;
+};
+exports.createCssValues = createCssValues;

package/dist/cjs/css-values/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoom = exports.zIndex = exports.widows = exports.strokeOpacity = exports.strokeMiterlimit = exports.stopOpacity = exports.shapeImageThreshold = exports.orphans = exports.order = exports.opacity = exports.mathDepth = exports.lineHeight = exports.lineClamp = exports.fontWeight = exports.fontSizeAdjust = exports.floodOpacity = exports.flexShrink = exports.flexGrow = exports.fillOpacity = exports.columnCount = exports.animationIterationCount = exports.CSS_VALUE_SPEC = exports.tabSize = exports.strokeWidth = exports.strokeDashoffset = exports.strokeDasharray = exports.span = exports.scale = exports.maskBorderWidth = exports.maskBorderSlice = exports.maskBorderOutset = exports.gridRowStart = exports.gridRowEnd = exports.gridColumnStart = exports.gridColumnEnd = exports.counterSet = exports.counterReset = exports.counterIncrement = exports.borderImageWidth = exports.borderImageSlice = exports.borderImageOutset = exports.createCssValues = void 0;
+// The per-property CSS-VALUE HELPER LAYER: typed helpers for single-value CSS
+// properties (`opacity`, `zIndex`, ...), each a constrained scalar (built on the
+// `i()` / `f()` primitives) plus that property's keyword companions, with
+// `.css()` typed against csstype's `Property`. The bare helper exports are
+// `createCssValues()` at its defaults (`outOfRange: 'throw'`).
+const cssValues_1 = require("./cssValues");
+var cssValues_2 = require("./cssValues");
+Object.defineProperty(exports, "createCssValues", { enumerable: true, get: function () { return cssValues_2.createCssValues; } });
+var multi_1 = require("./multi");
+Object.defineProperty(exports, "borderImageOutset", { enumerable: true, get: function () { return multi_1.borderImageOutset; } });
+Object.defineProperty(exports, "borderImageSlice", { enumerable: true, get: function () { return multi_1.borderImageSlice; } });
+Object.defineProperty(exports, "borderImageWidth", { enumerable: true, get: function () { return multi_1.borderImageWidth; } });
+Object.defineProperty(exports, "counterIncrement", { enumerable: true, get: function () { return multi_1.counterIncrement; } });
+Object.defineProperty(exports, "counterReset", { enumerable: true, get: function () { return multi_1.counterReset; } });
+Object.defineProperty(exports, "counterSet", { enumerable: true, get: function () { return multi_1.counterSet; } });
+Object.defineProperty(exports, "gridColumnEnd", { enumerable: true, get: function () { return multi_1.gridColumnEnd; } });
+Object.defineProperty(exports, "gridColumnStart", { enumerable: true, get: function () { return multi_1.gridColumnStart; } });
+Object.defineProperty(exports, "gridRowEnd", { enumerable: true, get: function () { return multi_1.gridRowEnd; } });
+Object.defineProperty(exports, "gridRowStart", { enumerable: true, get: function () { return multi_1.gridRowStart; } });
+Object.defineProperty(exports, "maskBorderOutset", { enumerable: true, get: function () { return multi_1.maskBorderOutset; } });
+Object.defineProperty(exports, "maskBorderSlice", { enumerable: true, get: function () { return multi_1.maskBorderSlice; } });
+Object.defineProperty(exports, "maskBorderWidth", { enumerable: true, get: function () { return multi_1.maskBorderWidth; } });
+Object.defineProperty(exports, "scale", { enumerable: true, get: function () { return multi_1.scale; } });
+Object.defineProperty(exports, "span", { enumerable: true, get: function () { return multi_1.span; } });
+Object.defineProperty(exports, "strokeDasharray", { enumerable: true, get: function () { return multi_1.strokeDasharray; } });
+Object.defineProperty(exports, "strokeDashoffset", { enumerable: true, get: function () { return multi_1.strokeDashoffset; } });
+Object.defineProperty(exports, "strokeWidth", { enumerable: true, get: function () { return multi_1.strokeWidth; } });
+Object.defineProperty(exports, "tabSize", { enumerable: true, get: function () { return multi_1.tabSize; } });
+var spec_1 = require("./spec");
+Object.defineProperty(exports, "CSS_VALUE_SPEC", { enumerable: true, get: function () { return spec_1.CSS_VALUE_SPEC; } });
+/** The default instance: the bare helpers below are bound to it. */
+const defaults = (0, cssValues_1.createCssValues)();
+exports.animationIterationCount = defaults.animationIterationCount, exports.columnCount = defaults.columnCount, exports.fillOpacity = defaults.fillOpacity, exports.flexGrow = defaults.flexGrow, exports.flexShrink = defaults.flexShrink, exports.floodOpacity = defaults.floodOpacity, exports.fontSizeAdjust = defaults.fontSizeAdjust, exports.fontWeight = defaults.fontWeight, exports.lineClamp = defaults.lineClamp, exports.lineHeight = defaults.lineHeight, exports.mathDepth = defaults.mathDepth, exports.opacity = defaults.opacity, exports.order = defaults.order, exports.orphans = defaults.orphans, exports.shapeImageThreshold = defaults.shapeImageThreshold, exports.stopOpacity = defaults.stopOpacity, exports.strokeMiterlimit = defaults.strokeMiterlimit, exports.strokeOpacity = defaults.strokeOpacity, exports.widows = defaults.widows, exports.zIndex = defaults.zIndex, exports.zoom = defaults.zoom;

package/dist/cjs/css-values/multi.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strokeDashoffset = exports.strokeWidth = exports.maskBorderSlice = exports.borderImageSlice = exports.maskBorderOutset = exports.maskBorderWidth = exports.borderImageOutset = exports.borderImageWidth = exports.tabSize = exports.gridColumnEnd = exports.gridColumnStart = exports.gridRowEnd = exports.gridRowStart = exports.span = exports.counterSet = exports.counterIncrement = exports.counterReset = void 0;
+exports.scale = scale;
+exports.strokeDasharray = strokeDasharray;
+const default_1 = require("../default");
+const float_1 = require("../float");
+const integer_1 = require("../integer");
+/**
+ * Wrap a finished render string as a typed value object. Every
+ * `MultiPropertyValueMap[CssProperty]` widens to include `(string & {})`, so the
+ * rendered `string` is directly assignable; no cast is needed.
+ */
+const wrap = (rendered) => ({
+    css: () => rendered,
+    toString: () => rendered,
+    value: () => rendered,
+});
+const CUSTOM_IDENT = /^-?[_a-zA-Z][\w-]*$/;
+const assertCustomIdent = (name, helper) => {
+    if (!CUSTOM_IDENT.test(name)) {
+        throw new Error(`${helper}: '${name}' is not a valid <custom-ident> ` +
+            `(letters, digits, '-', '_'; must not start with a digit)`);
+    }
+};
+/**
+ * Build a counter helper. Accepts the keyword `'none'`, or one or more
+ * `<custom-ident> <integer>?` entries. A bare ident uses `defaultValue`; a
+ * `[ident, n]` tuple hardens `n` through `i()` (any integer, negatives allowed).
+ */
+const makeCounterHelper = (helper, defaultValue) => (
+// `'none'` is accepted as the standalone keyword; at the type level it is a
+// `string`, indistinct from a `<custom-ident>`, so the union is just
+// `CounterEntry`. The keyword is recognized (and guarded against being
+// combined with entries) at runtime below.
+first, ...rest) => {
+    if (first === 'none') {
+        if (rest.length > 0) {
+            throw new Error(`${helper}: 'none' cannot be combined with counter entries`);
+        }
+        return wrap('none');
+    }
+    const entries = [
+        first,
+        ...rest,
+    ];
+    const parts = entries.map((entry) => {
+        const [name, value,] = typeof entry === 'string'
+            ? [
+                entry,
+                defaultValue,
+            ]
+            : entry;
+        assertCustomIdent(name, helper);
+        const n = (0, integer_1.i)(value, { context: helper }).css();
+        return `${name} ${n}`;
+    });
+    return wrap(parts.join(' '));
+};
+/**
+ * `counter-reset`: `<custom-ident> <integer>?` pairs (omitted integer defaults
+ * to `0`) or `none`. `.css()` is `Property.CounterReset`.
+ */
+exports.counterReset = makeCounterHelper('counterReset', 0);
+/**
+ * `counter-increment`: `<custom-ident> <integer>?` pairs (omitted integer
+ * defaults to `1`) or `none`. `.css()` is `Property.CounterIncrement`.
+ */
+exports.counterIncrement = makeCounterHelper('counterIncrement', 1);
+/**
+ * `counter-set`: `<custom-ident> <integer>?` pairs (omitted integer defaults to
+ * `0`) or `none`. `.css()` is `Property.CounterSet`.
+ */
+exports.counterSet = makeCounterHelper('counterSet', 0);
+/**
+ * Build a `span N` (optionally `span N name`) grid-line value. `count` is
+ * hardened to an integer `>= 1`. Pass the result to a grid-line helper:
+ * `gridColumnEnd(span(2))`.
+ */
+const span = (count, name) => ({
+    span: count,
+    name,
+});
+exports.span = span;
+const makeGridLineHelper = (helper) => (line) => {
+    if (typeof line === 'number') {
+        if (line === 0) {
+            throw new Error(`${helper}: a grid line number must be nonzero (got 0)`);
+        }
+        return wrap((0, integer_1.i)(line, { context: helper }).css());
+    }
+    if (typeof line === 'string') {
+        if (line === 'span') {
+            throw new Error(`${helper}: use span(n) to build a 'span' value`);
+        }
+        if (line !== 'auto') {
+            assertCustomIdent(line, helper);
+        }
+        return wrap(line);
+    }
+    // SpanInput
+    const count = (0, integer_1.i)(line.span, {
+        min: 1,
+        context: `${helper} span`,
+    }).css();
+    if (line.name !== undefined) {
+        assertCustomIdent(line.name, helper);
+        return wrap(`span ${count} ${line.name}`);
+    }
+    return wrap(`span ${count}`);
+};
+/** `grid-row-start`. `.css()` is `Property.GridRowStart`. */
+exports.gridRowStart = makeGridLineHelper('gridRowStart');
+/** `grid-row-end`. `.css()` is `Property.GridRowEnd`. */
+exports.gridRowEnd = makeGridLineHelper('gridRowEnd');
+/** `grid-column-start`. `.css()` is `Property.GridColumnStart`. */
+exports.gridColumnStart = makeGridLineHelper('gridColumnStart');
+/** `grid-column-end`. `.css()` is `Property.GridColumnEnd`. */
+exports.gridColumnEnd = makeGridLineHelper('gridColumnEnd');
+function scale(first, y, z) {
+    if (first === 'none') {
+        return wrap('none');
+    }
+    const factors = [
+        first,
+        y,
+        z,
+    ].filter((n) => n !== undefined);
+    const rendered = factors
+        .map((n) => (0, float_1.f)(n, { context: 'scale' }).css())
+        .join(' ');
+    return wrap(rendered);
+}
+// --- tab-size -------------------------------------------------------------
+/**
+ * `tab-size`: a `<number>` `>= 0` (NOT restricted to an integer; `2.5` is
+ * valid) hardened through `f()`, or a length supplied as an `IMeasurement`. The
+ * percentage form is out of scope. `.css()` is `Property.TabSize`.
+ */
+const tabSize = (value) => {
+    if (typeof value === 'number') {
+        return wrap((0, float_1.f)(value, { min: 0, context: 'tabSize' }).css());
+    }
+    return wrap(value.css());
+};
+exports.tabSize = tabSize;
+/**
+ * Render one number-or-length entry. A number is hardened through `f()` with the
+ * given bounds (so out-of-range / non-finite inputs throw); an `IMeasurement`
+ * renders through its `.css()`. Anything else throws with the helper name.
+ */
+const renderNumberOrLength = (entry, helper, min) => {
+    if (typeof entry === 'number') {
+        return (0, float_1.f)(entry, { min, context: helper }).css();
+    }
+    if ((0, default_1.isMeasurement)(entry)) {
+        return entry.css();
+    }
+    throw new Error(`${helper}: expected a <number> or an IMeasurement (got ${typeof entry})`);
+};
+/**
+ * Build a 1-to-4-value helper whose entries are each a `<number>` (hardened
+ * with `min`) or an `IMeasurement`, with an optional per-entry keyword
+ * (`'auto'` for the *-width properties). Mirrors the box-edge `{1,4}` shape
+ * (`border-image-width`, `border-image-outset`, ...): supply one to four
+ * entries, rendered space-separated in order.
+ */
+const makeEdgeQuadHelper = (helper, min, keywords) => (first, ...rest) => {
+    const entries = [
+        first,
+        ...rest,
+    ];
+    if (entries.length > 4) {
+        throw new Error(`${helper}: expected 1 to 4 entries (got ${entries.length})`);
+    }
+    const keywordSet = new Set(keywords);
+    const parts = entries.map((entry) => {
+        if (typeof entry === 'string') {
+            if (!keywordSet.has(entry)) {
+                throw new Error(`${helper}: '${entry}' is not a valid keyword` +
+                    ` (expected one of: ${keywords.join(', ') || 'none'})`);
+            }
+            return entry;
+        }
+        return renderNumberOrLength(entry, helper, min);
+    });
+    return wrap(parts.join(' '));
+};
+/**
+ * `border-image-width`: one to four entries, each a non-negative `<number>`
+ * multiplier (hardened through `f({ min: 0 })`), an `IMeasurement` length, or
+ * the keyword `'auto'`. `.css()` is `Property.BorderImageWidth`.
+ */
+exports.borderImageWidth = makeEdgeQuadHelper('borderImageWidth', 0, [
+    'auto',
+]);
+/**
+ * `border-image-outset`: one to four entries, each a non-negative `<number>`
+ * (hardened through `f({ min: 0 })`) or an `IMeasurement` length. `.css()` is
+ * `Property.BorderImageOutset`.
+ */
+exports.borderImageOutset = makeEdgeQuadHelper('borderImageOutset', 0, []);
+/**
+ * `mask-border-width`: like {@link borderImageWidth} (non-negative `<number>`,
+ * `IMeasurement`, or `'auto'`; one to four entries). `.css()` is
+ * `Property.MaskBorderWidth`.
+ */
+exports.maskBorderWidth = makeEdgeQuadHelper('maskBorderWidth', 0, [
+    'auto',
+]);
+/**
+ * `mask-border-outset`: like {@link borderImageOutset} (non-negative
+ * `<number>` or `IMeasurement`; one to four entries). `.css()` is
+ * `Property.MaskBorderOutset`.
+ */
+exports.maskBorderOutset = makeEdgeQuadHelper('maskBorderOutset', 0, []);
+/**
+ * Build a `border-image-slice` / `mask-border-slice` helper: one to four
+ * non-negative `<number>` entries (hardened through `f({ min: 0 })`; the
+ * percentage form is out of scope), with an optional trailing `'fill'`
+ * keyword. The slice properties accept numbers (and percentages), not lengths,
+ * so an `IMeasurement` is rejected.
+ */
+const makeSliceHelper = (helper) => (first, ...rest) => {
+    const all = [
+        first,
+        ...rest,
+    ];
+    let fill = false;
+    if (all[all.length - 1] === 'fill') {
+        fill = true;
+        all.pop();
+    }
+    if (all.some((entry) => entry === 'fill')) {
+        throw new Error(`${helper}: 'fill' may only appear as the trailing keyword`);
+    }
+    if (all.length < 1 || all.length > 4) {
+        throw new Error(`${helper}: expected 1 to 4 numbers (got ${all.length})`);
+    }
+    const parts = all.map((entry) => {
+        if (typeof entry !== 'number') {
+            throw new Error(`${helper}: expected a <number> (got ${typeof entry})`);
+        }
+        return (0, float_1.f)(entry, { min: 0, context: helper }).css();
+    });
+    if (fill) {
+        parts.push('fill');
+    }
+    return wrap(parts.join(' '));
+};
+/**
+ * `border-image-slice`: one to four non-negative `<number>` entries, with an
+ * optional trailing `'fill'` keyword. The percentage form is out of scope.
+ * `.css()` is `Property.BorderImageSlice`.
+ */
+exports.borderImageSlice = makeSliceHelper('borderImageSlice');
+/**
+ * `mask-border-slice`: like {@link borderImageSlice} (one to four non-negative
+ * `<number>` entries plus an optional trailing `'fill'`). `.css()` is
+ * `Property.MaskBorderSlice`.
+ */
+exports.maskBorderSlice = makeSliceHelper('maskBorderSlice');
+/**
+ * `stroke-width`: a single non-negative `<number>` (SVG user units, hardened
+ * through `f({ min: 0 })`) or an `IMeasurement` length. The percentage form is
+ * out of scope. `.css()` is `Property.StrokeWidth`.
+ */
+const strokeWidth = (value) => wrap(renderNumberOrLength(value, 'strokeWidth', 0));
+exports.strokeWidth = strokeWidth;
+/**
+ * `stroke-dashoffset`: a single `<number>` (any value; SVG user units, hardened
+ * through `f()`) or an `IMeasurement` length. The percentage form is out of
+ * scope. `.css()` is `Property.StrokeDashoffset`.
+ */
+const strokeDashoffset = (value) => wrap(renderNumberOrLength(value, 'strokeDashoffset'));
+exports.strokeDashoffset = strokeDashoffset;
+function strokeDasharray(first, ...rest) {
+    if (first === 'none') {
+        if (rest.length > 0) {
+            throw new Error(`strokeDasharray: 'none' cannot be combined with entries`);
+        }
+        return wrap('none');
+    }
+    const entries = [
+        first,
+        ...rest,
+    ];
+    const parts = entries.map((entry) => renderNumberOrLength(entry, 'strokeDasharray', 0));
+    return wrap(parts.join(' '));
+}

package/dist/cjs/css-values/propertyMap.js

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

package/dist/cjs/css-values/spec.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSS_VALUE_SPEC = void 0;
+/**
+ * Helper that ties a row's `name`, `cssProperty`, and `keywords` together while
+ * inferring each as a literal. Authoring a row through `row(...)` keeps `name`
+ * and `keywords` as literals (so the helper map key and keyword param stay
+ * precise) without sprinkling `as const` on every entry.
+ */
+const row = (entry) => entry;
+/**
+ * The css-value spec table: one row per single-value property. The factory in
+ * `./cssValues.ts` generates a typed helper from each row, so adding a property
+ * is a one-line table edit, not a hand-written function.
+ *
+ * Sourced from `docs/css-number-value-types.md`. Multi-value properties and
+ * those lacking a clean single-value mapping (e.g. `maxLines`, the counter
+ * trio, grid lines, `scale`, `tabSize`) are intentionally excluded.
+ */
+exports.CSS_VALUE_SPEC = [
+    // Opacity family: float, [0, 1], no keywords.
+    row({
+        name: 'opacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'Opacity',
+    }),
+    row({
+        name: 'fillOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'FillOpacity',
+    }),
+    row({
+        name: 'strokeOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'StrokeOpacity',
+    }),
+    row({
+        name: 'stopOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'StopOpacity',
+    }),
+    row({
+        name: 'floodOpacity',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'FloodOpacity',
+    }),
+    row({
+        name: 'shapeImageThreshold',
+        kind: 'float',
+        min: 0,
+        max: 1,
+        keywords: [],
+        cssProperty: 'ShapeImageThreshold',
+    }),
+    // Float, >= 0.
+    row({
+        name: 'lineHeight',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'normal',
+        ],
+        cssProperty: 'LineHeight',
+    }),
+    row({
+        name: 'flexGrow',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'FlexGrow',
+    }),
+    row({
+        name: 'flexShrink',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'FlexShrink',
+    }),
+    row({
+        name: 'animationIterationCount',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'infinite',
+        ],
+        cssProperty: 'AnimationIterationCount',
+    }),
+    row({
+        name: 'fontSizeAdjust',
+        kind: 'float',
+        min: 0,
+        keywords: [
+            'none',
+            'from-font',
+        ],
+        cssProperty: 'FontSizeAdjust',
+    }),
+    row({
+        name: 'zoom',
+        kind: 'float',
+        min: 0,
+        keywords: [],
+        cssProperty: 'Zoom',
+    }),
+    // Float, specific range.
+    row({
+        name: 'fontWeight',
+        kind: 'float',
+        min: 1,
+        max: 1000,
+        keywords: [
+            'normal',
+            'bold',
+            'lighter',
+            'bolder',
+        ],
+        cssProperty: 'FontWeight',
+    }),
+    row({
+        name: 'strokeMiterlimit',
+        kind: 'float',
+        min: 1,
+        keywords: [],
+        cssProperty: 'StrokeMiterlimit',
+    }),
+    // Integer, unbounded (negatives allowed).
+    row({
+        name: 'zIndex',
+        kind: 'int',
+        keywords: [
+            'auto',
+        ],
+        cssProperty: 'ZIndex',
+    }),
+    row({
+        name: 'order',
+        kind: 'int',
+        keywords: [],
+        cssProperty: 'Order',
+    }),
+    row({
+        name: 'mathDepth',
+        kind: 'int',
+        keywords: [
+            'auto-add',
+        ],
+        cssProperty: 'MathDepth',
+    }),
+    // Integer, min 1.
+    row({
+        name: 'columnCount',
+        kind: 'int',
+        min: 1,
+        keywords: [
+            'auto',
+        ],
+        cssProperty: 'ColumnCount',
+    }),
+    row({
+        name: 'orphans',
+        kind: 'int',
+        min: 1,
+        keywords: [],
+        cssProperty: 'Orphans',
+    }),
+    row({
+        name: 'widows',
+        kind: 'int',
+        min: 1,
+        keywords: [],
+        cssProperty: 'Widows',
+    }),
+    row({
+        name: 'lineClamp',
+        kind: 'int',
+        min: 1,
+        keywords: [
+            'none',
+        ],
+        cssProperty: 'WebkitLineClamp',
+    }),
+];

package/dist/cjs/default.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setErrorConfig = exports.getErrorConfig = exports.inRange = exports.nonPositive = exports.nonNegative = exports.makeMeasurementRefinement = exports.assertCondition = exports.assertUnit = exports.hasCssMethod = exports.makeUnitAssert = exports.makeUnitGuard = exports.makeUnitHelperFromDefinition = exports.makeUnitHelper = exports.measurementUnitMetadata = exports.measurementMax = exports.measurementMin = exports.assertMatchingUnits = exports.isMeasurement = exports.m = void 0;
+// THE DEFAULT INSTANCE. This module sits ABOVE both `core.ts` and `factory.ts`
+// and is the single place where the package's bare, default-instance helpers are
+// assembled. It calls the public factory `createCalipers()` at its defaults, so
+// the bare `m` / refinements / unit-helper builders below are exactly the same
+// construction path a consumer gets from `createCalipers()` with no config. The
+// default can no longer drift from a custom instance, because there is one path.
+//
+// `factory.ts` depends only on the `internal/*` builders (which import nothing
+// but TYPES from `core.ts`), so importing the factory here introduces no runtime
+// import cycle: `default.ts -> factory.ts -> internal/* -> core.ts (types only)`.
+// `core.ts` itself imports nothing from this module.
+const factory_1 = require("./factory");
+const defaultCalipers = (0, factory_1.createCalipers)();
+exports.m = defaultCalipers.m, exports.isMeasurement = defaultCalipers.isMeasurement, exports.assertMatchingUnits = defaultCalipers.assertMatchingUnits, exports.measurementMin = defaultCalipers.measurementMin, exports.measurementMax = defaultCalipers.measurementMax, exports.measurementUnitMetadata = defaultCalipers.measurementUnitMetadata, exports.makeUnitHelper = defaultCalipers.makeUnitHelper, exports.makeUnitHelperFromDefinition = defaultCalipers.makeUnitHelperFromDefinition, exports.makeUnitGuard = defaultCalipers.makeUnitGuard, exports.makeUnitAssert = defaultCalipers.makeUnitAssert, exports.hasCssMethod = defaultCalipers.hasCssMethod, exports.assertUnit = defaultCalipers.assertUnit, exports.assertCondition = defaultCalipers.assertCondition, exports.makeMeasurementRefinement = defaultCalipers.makeMeasurementRefinement, exports.nonNegative = defaultCalipers.nonNegative, exports.nonPositive = defaultCalipers.nonPositive, exports.inRange = defaultCalipers.inRange, exports.getErrorConfig = defaultCalipers.getErrorConfig, exports.setErrorConfig = defaultCalipers.setErrorConfig;