css-calipers 0.15.0 → 1.1.0-beta.0

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

@@ -0,0 +1,12 @@
+// 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'`).
+import { createCssValues } from './cssValues';
+export { createCssValues, } from './cssValues';
+export { borderImageOutset, borderImageSlice, borderImageWidth, counterIncrement, counterReset, counterSet, gridColumnEnd, gridColumnStart, gridRowEnd, gridRowStart, maskBorderOutset, maskBorderSlice, maskBorderWidth, scale, span, strokeDasharray, strokeDashoffset, strokeWidth, tabSize, } from './multi';
+export { CSS_VALUE_SPEC, } from './spec';
+/** The default instance: the bare helpers below are bound to it. */
+const defaults = createCssValues();
+export const { animationIterationCount, columnCount, fillOpacity, flexGrow, flexShrink, floodOpacity, fontSizeAdjust, fontWeight, lineClamp, lineHeight, mathDepth, opacity, order, orphans, shapeImageThreshold, stopOpacity, strokeMiterlimit, strokeOpacity, widows, zIndex, zoom, } = defaults;

package/dist/esm/css-values/multi.d.ts

@@ -0,0 +1,188 @@
+import type { Property } from 'csstype';
+import type { IMeasurement } from '../core';
+/**
+ * The MULTI-PART CSS-VALUE HELPER LAYER.
+ *
+ * The single-value layer in `./cssValues.ts` is table-driven: one constrained
+ * scalar plus a keyword union per property, rendered through `i()` / `f()`. The
+ * properties here do not fit that one-scalar-one-keyword shape. Each accepts a
+ * *composite* value: a list of `<custom-ident> <integer>` pairs (the counter
+ * trio), a tri-state grid-line position (integer line, `span N`, named line, or
+ * `auto`), one-to-three scale factors, or a number-or-length `tab-size`.
+ *
+ * They share the single layer's contracts: numeric pieces go through `i()` /
+ * `f()` (so out-of-range and non-integer inputs throw at build time), keywords
+ * pass through untouched, and `.css()` is typed against the property's csstype
+ * `Property.X` value type via {@link MultiPropertyValueMap}.
+ *
+ * Every value object exposes the same trio as the single layer's `CssValue`:
+ * `.css()` (typed render), `.toString()` (mirrors `.css()`), and `.value()`
+ * (the raw `string` render). Builders validate eagerly and throw on bad input.
+ */
+/**
+ * An indexable bridge over csstype's `Property` namespace for the multi-part
+ * properties, mirroring `./propertyMap.ts`'s {@link PropertyValueMap}. A helper's
+ * PascalCase key (e.g. `'CounterReset'`) indexes this to recover
+ * `Property.CounterReset`, so each `.css()` is typed against the right csstype
+ * value type. Add a helper here -> add its `Property` key.
+ */
+export interface MultiPropertyValueMap {
+    CounterReset: Property.CounterReset;
+    CounterIncrement: Property.CounterIncrement;
+    CounterSet: Property.CounterSet;
+    GridRowStart: Property.GridRowStart;
+    GridRowEnd: Property.GridRowEnd;
+    GridColumnStart: Property.GridColumnStart;
+    GridColumnEnd: Property.GridColumnEnd;
+    Scale: Property.Scale;
+    TabSize: Property.TabSize;
+    BorderImageWidth: Property.BorderImageWidth;
+    BorderImageOutset: Property.BorderImageOutset;
+    BorderImageSlice: Property.BorderImageSlice;
+    MaskBorderWidth: Property.MaskBorderWidth;
+    MaskBorderOutset: Property.MaskBorderOutset;
+    MaskBorderSlice: Property.MaskBorderSlice;
+    StrokeWidth: Property.StrokeWidth;
+    StrokeDashoffset: Property.StrokeDashoffset;
+    StrokeDasharray: Property.StrokeDasharray;
+}
+/** The set of csstype `Property` keys the multi-part layer covers. */
+export type MultiPropertyKey = keyof MultiPropertyValueMap;
+/**
+ * A single typed multi-part CSS value. Built through a property helper
+ * (`scale(1, 2)`, `counterReset(['page', 1])`), rendered with `.css()` (typed
+ * against the property's csstype `Property` key). `.value()` returns the raw
+ * rendered `string`; `.toString()` mirrors `.css()`.
+ */
+export interface MultiCssValue<CssProperty extends MultiPropertyKey> {
+    css: () => MultiPropertyValueMap[CssProperty];
+    toString: () => string;
+    value: () => string;
+}
+/**
+ * One `<custom-ident> <integer>?` entry of a counter property. A bare string is
+ * the ident with the property's default integer; a `[ident, integer]` tuple
+ * supplies the integer explicitly. The integer is hardened with `i()`.
+ */
+export type CounterEntry = string | readonly [
+    name: string,
+    value: number
+];
+/**
+ * `counter-reset`: `<custom-ident> <integer>?` pairs (omitted integer defaults
+ * to `0`) or `none`. `.css()` is `Property.CounterReset`.
+ */
+export declare const counterReset: (first: CounterEntry, ...rest: readonly CounterEntry[]) => MultiCssValue<"CounterReset">;
+/**
+ * `counter-increment`: `<custom-ident> <integer>?` pairs (omitted integer
+ * defaults to `1`) or `none`. `.css()` is `Property.CounterIncrement`.
+ */
+export declare const counterIncrement: (first: CounterEntry, ...rest: readonly CounterEntry[]) => MultiCssValue<"CounterIncrement">;
+/**
+ * `counter-set`: `<custom-ident> <integer>?` pairs (omitted integer defaults to
+ * `0`) or `none`. `.css()` is `Property.CounterSet`.
+ */
+export declare const counterSet: (first: CounterEntry, ...rest: readonly CounterEntry[]) => MultiCssValue<"CounterSet">;
+/**
+ * A grid-line position: a nonzero `<integer>` line number (negatives count from
+ * the end edge), `'auto'`, a `<custom-ident>` named line (a string that is not
+ * `'auto'` / `'span'`), or a `span N` count (`>= 1`) via {@link span}.
+ */
+export type GridLineInput = number | string | SpanInput;
+/** A `span <integer>` grid-line value, built by {@link span}. */
+export interface SpanInput {
+    readonly span: number;
+    readonly name?: string;
+}
+/**
+ * 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))`.
+ */
+export declare const span: (count: number, name?: string) => SpanInput;
+/** `grid-row-start`. `.css()` is `Property.GridRowStart`. */
+export declare const gridRowStart: (line: GridLineInput) => MultiCssValue<"GridRowStart">;
+/** `grid-row-end`. `.css()` is `Property.GridRowEnd`. */
+export declare const gridRowEnd: (line: GridLineInput) => MultiCssValue<"GridRowEnd">;
+/** `grid-column-start`. `.css()` is `Property.GridColumnStart`. */
+export declare const gridColumnStart: (line: GridLineInput) => MultiCssValue<"GridColumnStart">;
+/** `grid-column-end`. `.css()` is `Property.GridColumnEnd`. */
+export declare const gridColumnEnd: (line: GridLineInput) => MultiCssValue<"GridColumnEnd">;
+/**
+ * `scale`: one to three number factors (negatives allowed; the percentage form
+ * is out of scope), or the keyword `'none'`. Each factor is hardened through
+ * `f()`. `.css()` is `Property.Scale`.
+ */
+export declare function scale(keyword: 'none'): MultiCssValue<'Scale'>;
+export declare function scale(x: number, y?: number, z?: number): MultiCssValue<'Scale'>;
+/**
+ * `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`.
+ */
+export declare const tabSize: (value: number | IMeasurement) => MultiCssValue<"TabSize">;
+/**
+ * One entry of a number-or-length property: a unitless `<number>` (a
+ * css-calipers float input, hardened through `f()`) or a length supplied as an
+ * `IMeasurement` (rendered via its `.css()`). The percentage form is out of
+ * scope, so a percentage must be passed as an `IMeasurement` carrying a `%`
+ * unit, never as a bare number.
+ */
+export type NumberOrLength = number | IMeasurement;
+/**
+ * `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`.
+ */
+export declare const borderImageWidth: (first: NumberOrLength | string, ...rest: readonly (NumberOrLength | string)[]) => MultiCssValue<"BorderImageWidth">;
+/**
+ * `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`.
+ */
+export declare const borderImageOutset: (first: NumberOrLength | string, ...rest: readonly (NumberOrLength | string)[]) => MultiCssValue<"BorderImageOutset">;
+/**
+ * `mask-border-width`: like {@link borderImageWidth} (non-negative `<number>`,
+ * `IMeasurement`, or `'auto'`; one to four entries). `.css()` is
+ * `Property.MaskBorderWidth`.
+ */
+export declare const maskBorderWidth: (first: NumberOrLength | string, ...rest: readonly (NumberOrLength | string)[]) => MultiCssValue<"MaskBorderWidth">;
+/**
+ * `mask-border-outset`: like {@link borderImageOutset} (non-negative
+ * `<number>` or `IMeasurement`; one to four entries). `.css()` is
+ * `Property.MaskBorderOutset`.
+ */
+export declare const maskBorderOutset: (first: NumberOrLength | string, ...rest: readonly (NumberOrLength | string)[]) => MultiCssValue<"MaskBorderOutset">;
+/**
+ * `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`.
+ */
+export declare const borderImageSlice: (first: number, ...rest: readonly (number | "fill")[]) => MultiCssValue<"BorderImageSlice">;
+/**
+ * `mask-border-slice`: like {@link borderImageSlice} (one to four non-negative
+ * `<number>` entries plus an optional trailing `'fill'`). `.css()` is
+ * `Property.MaskBorderSlice`.
+ */
+export declare const maskBorderSlice: (first: number, ...rest: readonly (number | "fill")[]) => MultiCssValue<"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`.
+ */
+export declare const strokeWidth: (value: NumberOrLength) => MultiCssValue<"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`.
+ */
+export declare const strokeDashoffset: (value: NumberOrLength) => MultiCssValue<"StrokeDashoffset">;
+/**
+ * `stroke-dasharray`: the keyword `'none'`, or a list of one or more entries,
+ * each a 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.StrokeDasharray`.
+ */
+export declare function strokeDasharray(keyword: 'none'): MultiCssValue<'StrokeDasharray'>;
+export declare function strokeDasharray(first: NumberOrLength, ...rest: readonly NumberOrLength[]): MultiCssValue<'StrokeDasharray'>;
+//# sourceMappingURL=multi.d.ts.map

package/dist/esm/css-values/multi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi.d.ts","sourceRoot":"","sources":["../../../src/css-values/multi.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,281 @@
+import { isMeasurement } from '../default';
+import { f } from '../float';
+import { i } from '../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 = 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`.
+ */
+export const counterReset = makeCounterHelper('counterReset', 0);
+/**
+ * `counter-increment`: `<custom-ident> <integer>?` pairs (omitted integer
+ * defaults to `1`) or `none`. `.css()` is `Property.CounterIncrement`.
+ */
+export const counterIncrement = makeCounterHelper('counterIncrement', 1);
+/**
+ * `counter-set`: `<custom-ident> <integer>?` pairs (omitted integer defaults to
+ * `0`) or `none`. `.css()` is `Property.CounterSet`.
+ */
+export const 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))`.
+ */
+export const span = (count, name) => ({
+    span: count,
+    name,
+});
+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(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 = 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`. */
+export const gridRowStart = makeGridLineHelper('gridRowStart');
+/** `grid-row-end`. `.css()` is `Property.GridRowEnd`. */
+export const gridRowEnd = makeGridLineHelper('gridRowEnd');
+/** `grid-column-start`. `.css()` is `Property.GridColumnStart`. */
+export const gridColumnStart = makeGridLineHelper('gridColumnStart');
+/** `grid-column-end`. `.css()` is `Property.GridColumnEnd`. */
+export const gridColumnEnd = makeGridLineHelper('gridColumnEnd');
+export 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) => 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`.
+ */
+export const tabSize = (value) => {
+    if (typeof value === 'number') {
+        return wrap(f(value, { min: 0, context: 'tabSize' }).css());
+    }
+    return wrap(value.css());
+};
+/**
+ * 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 f(entry, { min, context: helper }).css();
+    }
+    if (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`.
+ */
+export const 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`.
+ */
+export const borderImageOutset = makeEdgeQuadHelper('borderImageOutset', 0, []);
+/**
+ * `mask-border-width`: like {@link borderImageWidth} (non-negative `<number>`,
+ * `IMeasurement`, or `'auto'`; one to four entries). `.css()` is
+ * `Property.MaskBorderWidth`.
+ */
+export const maskBorderWidth = makeEdgeQuadHelper('maskBorderWidth', 0, [
+    'auto',
+]);
+/**
+ * `mask-border-outset`: like {@link borderImageOutset} (non-negative
+ * `<number>` or `IMeasurement`; one to four entries). `.css()` is
+ * `Property.MaskBorderOutset`.
+ */
+export const 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 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`.
+ */
+export const 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`.
+ */
+export const 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`.
+ */
+export const strokeWidth = (value) => wrap(renderNumberOrLength(value, 'strokeWidth', 0));
+/**
+ * `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`.
+ */
+export const strokeDashoffset = (value) => wrap(renderNumberOrLength(value, 'strokeDashoffset'));
+export 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/esm/css-values/propertyMap.d.ts

@@ -0,0 +1,39 @@
+import type { Property } from 'csstype';
+/**
+ * An indexable bridge over csstype's `Property` NAMESPACE.
+ *
+ * csstype exposes per-property value types as namespace members (`Property.Opacity`,
+ * `Property.ZIndex`), and a namespace cannot be `keyof`-ed or indexed by a generic
+ * key. This interface re-exposes exactly the members the spec table uses, so a row's
+ * PascalCase `cssProperty` key (e.g. `'Opacity'`) can index it: `PropertyValueMap['Opacity']`
+ * is `Property.Opacity`. That is what lets one generic factory type every helper's
+ * `.css()` return against the right csstype value type.
+ *
+ * Add a row to the spec table -> add its `Property` key here.
+ */
+export interface PropertyValueMap {
+    Opacity: Property.Opacity;
+    FillOpacity: Property.FillOpacity;
+    StrokeOpacity: Property.StrokeOpacity;
+    StopOpacity: Property.StopOpacity;
+    FloodOpacity: Property.FloodOpacity;
+    ShapeImageThreshold: Property.ShapeImageThreshold;
+    LineHeight: Property.LineHeight;
+    FlexGrow: Property.FlexGrow;
+    FlexShrink: Property.FlexShrink;
+    AnimationIterationCount: Property.AnimationIterationCount;
+    FontSizeAdjust: Property.FontSizeAdjust;
+    Zoom: Property.Zoom;
+    FontWeight: Property.FontWeight;
+    StrokeMiterlimit: Property.StrokeMiterlimit;
+    ZIndex: Property.ZIndex;
+    Order: Property.Order;
+    MathDepth: Property.MathDepth;
+    ColumnCount: Property.ColumnCount;
+    Orphans: Property.Orphans;
+    Widows: Property.Widows;
+    WebkitLineClamp: Property.WebkitLineClamp;
+}
+/** The set of csstype `Property` keys the css-value layer covers. */
+export type CssPropertyKey = keyof PropertyValueMap;
+//# sourceMappingURL=propertyMap.d.ts.map

package/dist/esm/css-values/propertyMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyMap.d.ts","sourceRoot":"","sources":["../../../src/css-values/propertyMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC;IAC1B,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC;IAClC,aAAa,EAAE,QAAQ,CAAC,aAAa,CAAC;IACtC,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC;IAClC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC;IACpC,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAClD,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAChC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAC5B,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAChC,uBAAuB,EAAE,QAAQ,CAAC,uBAAuB,CAAC;IAC1D,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC;IACxC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAChC,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAC5C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;IACxB,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC;IACtB,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;IAC9B,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC;IAClC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC;IAC1B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;IACxB,eAAe,EAAE,QAAQ,CAAC,eAAe,CAAC;CAC3C;AAED,qEAAqE;AACrE,MAAM,MAAM,cAAc,GAAG,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/css-values/spec.d.ts

@@ -0,0 +1,36 @@
+import type { CssPropertyKey } from './propertyMap';
+/**
+ * One row of the css-value spec table. Each row describes a single-value CSS
+ * property: the constrained scalar (an integer or a float, with optional
+ * `min`/`max` bounds) plus that property's keyword companions.
+ *
+ * - `name` is the camelCase helper name (`opacity`, `zIndex`).
+ * - `cssProperty` is the csstype `Property` key, so `.css()` is typed against
+ *   that property's `Property.X` value type (via `PropertyValueMap`).
+ * - `keywords` is the literal union of bare keywords the property also accepts
+ *   (`'auto'`, `'normal'`, ...). It passes through untouched.
+ *
+ * The two generics (`CssProperty`, `Keyword`) are preserved per row so each
+ * generated helper carries its own `.css()` return type and keyword union.
+ */
+export interface SpecRow<Name extends string = string, CssProperty extends CssPropertyKey = CssPropertyKey, Keyword extends string = string> {
+    readonly name: Name;
+    readonly kind: 'int' | 'float';
+    readonly min?: number;
+    readonly max?: number;
+    readonly keywords: readonly Keyword[];
+    readonly cssProperty: CssProperty;
+}
+/**
+ * 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.
+ */
+export declare const CSS_VALUE_SPEC: readonly [SpecRow<"opacity", "Opacity", never>, SpecRow<"fillOpacity", "FillOpacity", never>, SpecRow<"strokeOpacity", "StrokeOpacity", never>, SpecRow<"stopOpacity", "StopOpacity", never>, SpecRow<"floodOpacity", "FloodOpacity", never>, SpecRow<"shapeImageThreshold", "ShapeImageThreshold", never>, SpecRow<"lineHeight", "LineHeight", "normal">, SpecRow<"flexGrow", "FlexGrow", never>, SpecRow<"flexShrink", "FlexShrink", never>, SpecRow<"animationIterationCount", "AnimationIterationCount", "infinite">, SpecRow<"fontSizeAdjust", "FontSizeAdjust", "from-font" | "none">, SpecRow<"zoom", "Zoom", never>, SpecRow<"fontWeight", "FontWeight", "normal" | "bold" | "bolder" | "lighter">, SpecRow<"strokeMiterlimit", "StrokeMiterlimit", never>, SpecRow<"zIndex", "ZIndex", "auto">, SpecRow<"order", "Order", never>, SpecRow<"mathDepth", "MathDepth", "auto-add">, SpecRow<"columnCount", "ColumnCount", "auto">, SpecRow<"orphans", "Orphans", never>, SpecRow<"widows", "Widows", never>, SpecRow<"lineClamp", "WebkitLineClamp", "none">];
+/** The spec table's type (a readonly tuple of {@link SpecRow}s). */
+export type CssValueSpec = typeof CSS_VALUE_SPEC;
+//# sourceMappingURL=spec.d.ts.map

package/dist/esm/css-values/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../../src/css-values/spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,OAAO,CACtB,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,WAAW,SAAS,cAAc,GAAG,cAAc,EACnD,OAAO,SAAS,MAAM,GAAG,MAAM;IAE/B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAgBD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,qgCAqLjB,CAAC;AAEX,oEAAoE;AACpE,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC"}