fashionable 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,276 @@
+# fashionable
+
+Structural stylesheet modeling and calc expression evaluation for TypeScript (npm: `fashionable`).
+
+An Effect-style API for building CSS in code: a faithful structural model of the CSS language — rules, selectors, media queries, at-rules, nesting — unified with a `calc()` value-expression language that can be solved against bindings or serialized to CSS text. Immutable values, structural equality, deterministic output, zero runtime dependencies. No template literals anywhere.
+
+```sh
+npm install fashionable
+```
+
+## Typed calc
+
+A `Calc` is a CSS math expression you can serialize to CSS or solve to a number — the same tree, two projections, so the thing you verified is the thing you shipped. The type tracks the expression's unbound references, its dimension (`<number>`, `<length>`, `<angle>`, or `<percentage>`), and the units it mentions.
+
+```ts
+import { Calc } from 'fashionable/calc'
+import { Length } from 'fashionable/data'
+
+const fluid = Calc.clamp(
+  Length.rem(1),
+  Calc.add(Length.rem(0.75), Length.vw(0.5)),
+  Length.rem(1.25),
+)
+
+Calc.serialize(fluid) // 'clamp(1rem, 0.75rem + 0.5vw, 1.25rem)'
+Calc.solve(fluid, {}, { rem: 16, vw: 1280 / 100 }) // 18.4 — at a 1280px viewport, 16px root
+```
+
+`solve` lowers relative units through a context of px ratios, typed by the expression's units so the context can neither miss nor mismatch a key. Absolute lengths and angles solve with no context. `Length`, `Angle`, and `Percentage` in `fashionable/data` supply the unit constructors — `Length.px` through `Length.vmax`, `Angle.rad` and `Angle.deg`, `Percentage.of` — with `Unit` naming the unit types. A percentage serializes but does not solve.
+
+References are CSS custom properties: `Calc.ref('space')` reads `var(--space)`, and `bind` substitutes and partially evaluates.
+
+```ts
+const gap = Calc.multiply(Calc.ref('space'), 2)
+
+Calc.serialize(gap) // 'calc(var(--space) * 2)'
+Calc.solve(gap.pipe(Calc.bind({ space: 4 }))) // 8
+```
+
+The dimensional rules follow CSS and live in the types: `add`, `subtract`, `min`, `max`, and `clamp` require a shared kind, `multiply` scales a dimension by a number, and `divide` of two like dimensions is a number. Illegal combinations fail to typecheck rather than emitting invalid CSS.
+
+```ts
+// @ts-expect-error — a <length> plus a <number> has no CSS meaning
+Calc.add(Length.px(10), 5)
+// @ts-expect-error — two lengths do not multiply
+Calc.multiply(Length.px(10), Length.px(10))
+
+const ratio = Calc.divide(Calc.subtract(Length.vw(100), Length.px(320)), Length.px(160))
+
+Calc.serialize(ratio) // 'calc((100vw - 320px) / 160px)' — a <length> over a <length> is a <number>
+Calc.solve(ratio, {}, { vw: 1280 / 100 }) // 6
+```
+
+Firefox does not yet support `<length> / <length>` division in `calc()`; `tan(atan2(y, x))` is the portable spelling of the same ratio.
+
+```ts
+const portable = Calc.tan(Calc.atan2(Calc.subtract(Length.vw(100), Length.px(320)), Length.px(160)))
+
+Calc.serialize(portable) // 'tan(atan2(100vw - 320px, 160px))'
+```
+
+`mod`, `pow`/`signedPow`, `lerp`, `abs`, and `sin`/`cos`/`acos` round out the combinators. Trig follows CSS's typing: `acos` and `atan2` return an `<angle>`, and `sin`/`cos`/`tan` accept an `<angle>` or a plain number in radians.
+
+Constants format under an explicit precision model: five decimals by default, overridable per serialize call, and per constant with an annotation that carries through constant folding.
+
+```ts
+import { Precision } from 'fashionable/calc'
+
+Calc.serialize(Calc.of(0.8377580409572781)) // '0.83776'
+Calc.serialize(Calc.of(0.8377580409572781, Precision.significant(10))) // '0.837758041'
+```
+
+The full precision model lives in [docs/design.md](https://github.com/tkofh/fashionable/blob/main/docs/design.md).
+
+## Color
+
+A `Color` models a CSS color value structurally. Channels are `Calc` number expressions, so a channel can be a constant, a reference, arithmetic, or CSS's `none` keyword. A `Color` serializes and binds; it does not solve.
+
+```ts
+import { Calc } from 'fashionable/calc'
+import { Channel, Color, ColorSpace, HueInterpolation, Keyword } from 'fashionable/data'
+
+Color.serialize(Color.oklch(0.7, 0.15, Calc.ref('hue'))) // 'oklch(0.7 0.15 var(--hue))'
+Color.serialize(Color.srgb(0.18, 0.34, 0.78)) // 'color(srgb 0.18 0.34 0.78)'
+Color.serialize(Color.oklch(0.2, 0, Keyword.none)) // 'oklch(0.2 0 none)'
+
+Color.oklch(Calc.ref('l'), 0.15, 250).pipe(Color.bind({ l: 0.7 })) // serializes 'oklch(0.7 0.15 250)'
+```
+
+**Relative color syntax.** `Color.from` derives a color from another — including one the browser resolves from the cascade. The destination space exposes the origin's channels as `Channel` keywords and scopes them: `Channel.L` belongs to `oklch`, `Channel.R` to `srgb`, and a keyword the space does not name is a compile error.
+
+```ts
+const hover = Color.from(
+  Color.ref('accent'), // reads the whole color from var(--accent)
+  ColorSpace.oklch,
+  Calc.multiply(Channel.L, 0.8),
+  Channel.C,
+  Channel.H,
+)
+
+Color.serialize(hover) // 'oklch(from var(--accent) calc(l * 0.8) c h)'
+```
+
+**Mixing.** `Color.mix` models `color-mix()`. Arms are colors or `[color, weight]` tuples, weights read as percents. A polar space admits a `HueInterpolation` strategy after it; a strategy after a rectangular space is a compile error, matching the grammar.
+
+```ts
+const wash = Color.mix(ColorSpace.oklch, [Color.ref('brand'), 60], Color.named('white'))
+
+Color.serialize(wash) // 'color-mix(in oklch, var(--brand) 60%, white)'
+
+const arc = Color.mix(
+  ColorSpace.oklch,
+  HueInterpolation.longer,
+  Color.oklch(0.7, 0.15, 30),
+  Color.oklch(0.7, 0.15, 330),
+)
+
+Color.serialize(arc) // 'color-mix(in oklch longer hue, oklch(0.7 0.15 30), oklch(0.7 0.15 330))'
+```
+
+**Hue interpolation.** `HueInterpolation.interpolate` is the JS side of that hue arc: it builds the hue at `t` along the chosen strategy — the CSS Color 4 hue fixup written branchlessly with `mod` — folding to a constant when every argument is a number and staying symbolic otherwise. Your build and the browser compute the same fixup.
+
+```ts
+const hue = HueInterpolation.interpolate(
+  HueInterpolation.shorter,
+  30,
+  Calc.ref('to'),
+  Calc.ref('t'),
+)
+
+Calc.serialize(hue) // 'calc(30 + (mod(var(--to) - 30 + 180, 360) - 180) * var(--t))'
+Calc.serialize(HueInterpolation.interpolate(HueInterpolation.increasing, 20, 350, 0.5)) // '185'
+```
+
+**Whole-value colors.** `Color.lightDark` models scheme-conditional `light-dark()` with whole colors in each arm. `Color.ref` reads an entire color from a custom property, `Color.named` renders a named color bare, and `Color.transparent` is the blessed no-color constant. All of them compose anywhere a `Color` goes.
+
+```ts
+const scheme = Color.lightDark(Color.oklch(0.98, 0.01, 250), Color.oklch(0.18, 0.02, 250))
+
+Color.serialize(scheme) // 'light-dark(oklch(0.98 0.01 250), oklch(0.18 0.02 250))'
+Color.serialize(Color.lightDark(Color.ref('surface'), Color.transparent))
+// 'light-dark(var(--surface), transparent)'
+```
+
+## Stylesheets
+
+Build a stylesheet from typed parts — selectors, declarations, rules, nested media — then render it to CSS.
+
+```ts
+import { Calc } from 'fashionable/calc'
+import { Length } from 'fashionable/data'
+import { Declaration } from 'fashionable/declaration'
+import { MediaQuery } from 'fashionable/query'
+import { MediaRule, RuleSet, StyleRule } from 'fashionable/rule'
+import { Selector } from 'fashionable/selector'
+import { Stylesheet } from 'fashionable/stylesheet'
+
+const card = StyleRule.make(
+  Selector.class('card'),
+  RuleSet.make(
+    Declaration.make('padding', Length.rem(1)),
+    Declaration.make('gap', Calc.multiply(Calc.ref('space'), 2)),
+    MediaRule.make(
+      MediaQuery.minWidth(768),
+      RuleSet.make(Declaration.make('gap', Calc.multiply(Calc.ref('space'), 3))),
+    ),
+  ),
+)
+
+const sheet = Stylesheet.make(card) // Stylesheet<'space'>
+
+Stylesheet.render(sheet, { indent: '  ' })
+```
+
+Nesting is preserved as authored — `@media` stays inside its rule:
+
+```css
+.card {
+  padding: 1rem;
+  gap: calc(var(--space) * 2);
+  @media (min-width: 768px) {
+    gap: calc(var(--space) * 3);
+  }
+}
+```
+
+Selectors are compound selectors built from typed parts — `type`, `id`, `class`, `attribute`, `not`, pseudo-classes and pseudo-elements — with computed `Specificity`. Media queries are and-sets of `minWidth` and `prefersColorScheme`. Both canonicalize at construction, so structural equality holds regardless of construction order and rendering is deterministic. Declaration and rule order is never touched: member order is cascade behavior, and the library preserves it.
+
+A block built up through `pipe` caps off as a rule with `forSelector` or `forMediaQuery`:
+
+```ts
+RuleSet.make(Declaration.make('--depth', Calc.ref('depth'))).pipe(
+  RuleSet.forSelector(Selector.root),
+) // StyleRule<'depth'> — renders ':root { --depth: var(--depth); }'
+```
+
+## Refs
+
+Every value and container is generic over `Refs`, the CSS custom properties it reads but has not bound. `Calc.ref('space')` is a `Calc<'space'>` and `Color.ref('accent')` is a `Color<'accent'>`. Combining values unions their `Refs`, and `bind` subtracts the names it binds. A closed expression — fully bound or constant — is a `Calc<never>`, which is what `solve` accepts with no bindings.
+
+The parameter threads up through the model, so `Declaration<Refs>`, `RuleSet<Refs>`, `StyleRule<Refs>`, and `Stylesheet<Refs>` carry the union of the refs they contain. The `Stylesheet<'space'>` above is the compiler reporting that the sheet reads `var(--space)` and nothing else. `Stylesheet.refs` returns the same set at runtime. Unbound refs serialize as `var(--name)` — the reference channel is the custom-property channel.
+
+## `@property` and `@font-face`
+
+`PropertyRule` models `@property`. The `PropertySyntax` value in the `syntax` slot types the initial value, and the spec's computational-independence rule rides along: `Length.px(8)` registers under `PropertySyntax.length`, and `Length.vw(8)` is a compile error. Rules register with `inherits: false`; pipe through `PropertyRule.inheritable` to opt in.
+
+```ts
+import { PropertyRule, PropertySyntax } from 'fashionable/property'
+
+const depth = PropertyRule.make('--depth', PropertySyntax.number, 0)
+
+PropertyRule.render(depth, { indent: '  ' })
+// @property --depth {
+//   syntax: '<number>';
+//   inherits: false;
+//   initial-value: 0;
+// }
+```
+
+`FontFaceRule` models `@font-face`: multi-source `src`, weight ranges, metric overrides, and `unicode-range`.
+
+```ts
+import { FontFaceRule } from 'fashionable/font-face'
+
+const inter = FontFaceRule.make({
+  family: 'Inter',
+  src: [FontFaceRule.url('/fonts/inter.woff2', 'woff2'), FontFaceRule.local('Inter')],
+  weight: [400, 700],
+  display: 'swap',
+  unicodeRange: [[0x400, 0x4ff]],
+})
+
+FontFaceRule.render(inter, { indent: '  ' })
+// @font-face {
+//   font-family: 'Inter';
+//   font-weight: 400 700;
+//   font-display: swap;
+//   src:
+//     url('/fonts/inter.woff2') format('woff2'),
+//     local('Inter');
+//   unicode-range: U+400-4FF;
+// }
+```
+
+## Merging and coalescing
+
+`Stylesheet.merge` is a lawful monoid — associative, idempotent, `empty` as identity — that keeps both sides' order and collapses structural duplicates to their first occurrence. That is the multi-emitter fold: emitters that each register the rules they share merge to a sheet carrying one copy.
+
+```ts
+import { Stylesheet } from 'fashionable/stylesheet'
+
+const contract = Stylesheet.make(PropertyRule.make('--depth', PropertySyntax.number, 0))
+
+Stylesheet.merge(contract, contract) === contract // true — idempotent, by reference
+```
+
+`coalesce` folds style rules that share a selector into the first occurrence:
+
+```ts
+const sheet = Stylesheet.make(
+  StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--a', 1))),
+  StyleRule.make(Selector.root, RuleSet.make(Declaration.make('--b', 2))),
+)
+
+Stylesheet.render(Stylesheet.coalesce(sheet), { indent: '  ' })
+// :root {
+//   --a: 1;
+//   --b: 2;
+// }
+```
+
+Coalescing is order-sensitive: pulling a block backward past a rule whose selector ties on specificity can change the cascade. So it stays an explicit opt-in, and `coalesce(sheet, { strict: true })` throws on any such pull — a build gate proving the normalization is cascade-preserving.
+
+## License
+
+MIT

package/dist/calc/index.d.mts

@@ -0,0 +1,2 @@
+import { l as precision_d_exports, s as calc_d_exports } from "../shared/index-BvtwY4FQ.mjs";
+export { calc_d_exports as Calc, precision_d_exports as Precision };

package/dist/calc/index.mjs

@@ -1,335 +1,2 @@
-import { c as __exportAll } from "../shared/equal-C96LR7p4.mjs";
-import { D as signedPow$1, E as sign$1, F as significant$1, N as decimals$1, O as sin$1, P as isPrecision$1, S as refs$1, a as clamp$1, b as pow$1, c as divide$1, d as lerp$1, f as max$1, i as bind$1, j as subtract$1, k as solve$1, l as equals$1, m as multiply$1, n as acos$1, p as min$1, r as add$1, s as cos$1, t as abs$1, u as isCalc$1, w as serialize$1, x as ref$1, y as of$1 } from "../shared/calc.internal-C1g_NRsl.mjs";
-//#region src/calc/calc.ts
-var calc_exports = /* @__PURE__ */ __exportAll({
-	abs: () => abs,
-	acos: () => acos,
-	add: () => add,
-	bind: () => bind,
-	clamp: () => clamp,
-	cos: () => cos,
-	divide: () => divide,
-	equals: () => equals,
-	isCalc: () => isCalc,
-	lerp: () => lerp,
-	max: () => max,
-	min: () => min,
-	multiply: () => multiply,
-	of: () => of,
-	pow: () => pow,
-	ref: () => ref,
-	refs: () => refs,
-	serialize: () => serialize,
-	sign: () => sign,
-	signedPow: () => signedPow,
-	sin: () => sin,
-	solve: () => solve,
-	subtract: () => subtract
-});
-/**
-* Checks if a value is a `Calc`.
-*
-* True only for values built by this module's constructors, which carry
-* the brand.
-*
-* @param u - The value to check.
-* @returns `true` if the value is a `Calc`, `false` otherwise.
-* @since 0.1.0
-*/
-const isCalc = isCalc$1;
-/**
-* Creates a constant expression, optionally annotated with a serialization
-* precision that overrides the context default wherever the constant lands
-* — including in constants produced by folding it with others (the
-* highest-fidelity operand annotation wins).
-*
-* Bare numbers passed to combinators become unannotated constants; `of`
-* exists to name a value or pin its precision.
-*
-* @param value - The constant value. Must be finite.
-* @param precision - Optional precision annotation.
-* @returns A constant `Calc<never>`.
-* @throws `Error` when `value` is not finite.
-* @example
-* ```ts
-* const k = Calc.of(0.8377580409572781, Precision.significant(10))
-* Calc.serialize(Calc.multiply(k, Calc.ref('t'))) // 'calc(0.837758041 * var(--t))'
-* ```
-* @since 0.1.0
-*/
-const of = of$1;
-/**
-* Creates a reference to an unbound name. References serialize as
-* `var(--name)` and are the channel through which expressions read CSS
-* custom properties; `bind` replaces them with values or other
-* expressions.
-*
-* Repeated calls with the same name return the same instance.
-*
-* @param name - The reference name, without the `--` prefix. Must be non-empty.
-* @returns A `Calc` with `name` as its one unbound reference.
-* @throws `Error` when `name` is empty.
-* @example
-* ```ts
-* Calc.serialize(Calc.ref('width')) // 'var(--width)'
-* ```
-* @since 0.1.0
-*/
-const ref = ref$1;
-/**
-* Adds expressions. Constant operands fold at construction.
-*
-* Serializes as `a + b + ...` inside a `calc()` wrapper; negative constant
-* terms (and products led by a negative constant) render subtractively:
-* `a + (-2)` serializes as `a - 2`.
-*
-* @param a - The first operand.
-* @param b - The second operand.
-* @returns The sum, with the operands' references unioned.
-* @example
-* ```ts
-* Calc.serialize(Calc.add(Calc.ref('x'), 10)) // 'calc(var(--x) + 10)'
-* ```
-* @since 0.1.0
-*/
-const add = add$1;
-/**
-* Subtracts `right` from `left`. Constant operands fold at construction.
-*
-* @param left - The minuend.
-* @param right - The subtrahend.
-* @returns The difference, with the operands' references unioned.
-* @since 0.1.0
-*/
-const subtract = subtract$1;
-/**
-* Multiplies expressions. Constant operands fold at construction.
-*
-* Addition and subtraction operands are parenthesized when serialized
-* under a product: `(a + b) * c`.
-*
-* @param left - The first factor.
-* @param right - The second factor.
-* @returns The product, with the operands' references unioned.
-* @since 0.1.0
-*/
-const multiply = multiply$1;
-/**
-* Divides `left` by `right`. Constant operands fold at construction.
-*
-* @param left - The dividend.
-* @param right - The divisor.
-* @returns The quotient, with the operands' references unioned.
-* @since 0.1.0
-*/
-const divide = divide$1;
-/**
-* Raises `base` to `exponent`. Serializes as the CSS `pow()` function.
-*
-* @param base - The base.
-* @param exponent - The exponent.
-* @returns The power, with the operands' references unioned.
-* @since 0.1.0
-*/
-const pow = pow$1;
-/**
-* Sign-preserving power: `abs(base) ^ exponent * sign(base)`. Unlike
-* `pow`, well-defined for negative bases with fractional exponents.
-* Serializes as `pow(abs(base), exponent) * sign(base)`.
-*
-* @param base - The base.
-* @param exponent - The exponent.
-* @returns The signed power, with the operands' references unioned.
-* @since 0.1.0
-*/
-const signedPow = signedPow$1;
-/**
-* The minimum of the operands. Serializes as the CSS `min()` function.
-*
-* @param a - The first operand.
-* @param b - The second operand.
-* @returns The minimum, with the operands' references unioned.
-* @since 0.1.0
-*/
-const min = min$1;
-/**
-* The maximum of the operands. Serializes as the CSS `max()` function.
-*
-* @param a - The first operand.
-* @param b - The second operand.
-* @returns The maximum, with the operands' references unioned.
-* @since 0.1.0
-*/
-const max = max$1;
-/**
-* Clamps `value` between `minimum` and `maximum`. Serializes as the CSS
-* `clamp()` function, with the CSS argument order `(min, value, max)`.
-*
-* @param minimum - The lower bound.
-* @param value - The value to clamp.
-* @param maximum - The upper bound.
-* @returns The clamped expression, with the operands' references unioned.
-* @example
-* ```ts
-* Calc.serialize(Calc.clamp(-1, Calc.ref('u'), 1)) // 'clamp(-1, var(--u), 1)'
-* ```
-* @since 0.1.0
-*/
-const clamp = clamp$1;
-/**
-* Linear interpolation from `a` to `b` by `t`. This is sugar, not a node:
-* it desugars to `(1 - t) * a + t * b`, and serializes as that expanded
-* form.
-*
-* @param a - The value at `t = 0`.
-* @param b - The value at `t = 1`.
-* @param t - The interpolation parameter.
-* @returns The interpolated expression, with the operands' references unioned.
-* @since 0.1.0
-*/
-const lerp = lerp$1;
-/**
-* The absolute value. Serializes as the CSS `abs()` function.
-*
-* @param argument - The operand.
-* @returns The absolute value expression.
-* @since 0.1.0
-*/
-const abs = abs$1;
-/**
-* The sign (`-1`, `0`, or `1`). Serializes as the CSS `sign()` function.
-*
-* @param argument - The operand.
-* @returns The sign expression.
-* @since 0.1.0
-*/
-const sign = sign$1;
-/**
-* The sine of an angle in radians. Serializes as the CSS `sin()`
-* function; CSS treats a plain-number argument as radians, so no unit
-* conversion is involved.
-*
-* @param argument - The angle, in radians.
-* @returns The sine expression.
-* @since 0.1.0
-*/
-const sin = sin$1;
-/**
-* The cosine of an angle in radians. Serializes as the CSS `cos()`
-* function; CSS treats a plain-number argument as radians, so no unit
-* conversion is involved.
-*
-* @param argument - The angle, in radians.
-* @returns The cosine expression.
-* @since 0.1.0
-*/
-const cos = cos$1;
-/**
-* The arccosine of a value in `[-1, 1]`, in radians. Solving evaluates
-* `Math.acos`.
-*
-* Serialization note: CSS's `acos()` returns an `<angle>`, not a number.
-* The serializer keeps such subtrees angle-typed — plain-number terms
-* added to or subtracted from an acos-carrying term are rendered with a
-* `rad` suffix (constants) or a `* 1rad` factor (anything else), so the
-* emitted CSS stays valid without typed division. In v1, consume
-* acos-carrying subtrees with `sin` or `cos`; feeding one into a plain
-* number context serializes to angle-typed CSS.
-*
-* @param argument - The cosine value, in `[-1, 1]`.
-* @returns The arccosine expression, in radians.
-* @example
-* ```ts
-* Calc.serialize(Calc.cos(Calc.subtract(Calc.divide(Calc.acos(Calc.ref('u')), 3), 2.0943951)))
-* // 'cos(acos(var(--u)) / 3 - 2.0944rad)'
-* ```
-* @since 0.1.0
-*/
-const acos = acos$1;
-const bind = bind$1;
-const solve = solve$1;
-/**
-* Renders an expression as CSS text. Arithmetic gets a `calc()` wrapper;
-* function forms (`min`, `clamp`, `sin`, ...) and leaves stand alone.
-* References render as `var(--name)`.
-*
-* Bindings in `options` are applied first and may be partial — this is
-* the serialize half of the solve/serialize duality, and unbound
-* references are the values left for the browser. Constants render with
-* their annotated precision, or the context `precision` option (default
-* `Precision.decimals(5)`). Constants equal to pi render as the CSS
-* constant `pi` where a math function surrounds them.
-*
-* @param expr - The expression to render.
-* @param options - Optional bindings and precision context.
-* @returns Deterministic CSS text.
-* @example
-* ```ts
-* const fluid = Calc.add(10, Calc.ref('runtime'))
-* Calc.serialize(fluid) // 'calc(10 + var(--runtime))'
-* Calc.serialize(fluid, { bindings: { runtime: 4 } }) // '14'
-* ```
-* @since 0.1.0
-*/
-const serialize = serialize$1;
-/**
-* The expression's unbound reference names.
-*
-* @param expr - The expression to inspect.
-* @returns The set of unbound reference names.
-* @since 0.1.0
-*/
-const refs = refs$1;
-const equals = equals$1;
-//#endregion
-//#region src/calc/precision.ts
-var precision_exports = /* @__PURE__ */ __exportAll({
-	decimals: () => decimals,
-	isPrecision: () => isPrecision,
-	significant: () => significant
-});
-/**
-* Checks if a value is a `Precision`.
-*
-* True only for values built by `decimals` or `significant`, which carry
-* the brand.
-*
-* @param u - The value to check.
-* @returns `true` if the value is a `Precision`, `false` otherwise.
-* @since 0.1.0
-*/
-const isPrecision = isPrecision$1;
-/**
-* Creates a `Precision` fixing the count of digits after the decimal
-* point. The library default for unannotated constants is `decimals(5)`.
-*
-* @param digits - Digits after the decimal point. Must be an integer in `[0, 100]`.
-* @returns A `Precision` in `decimals` mode.
-* @throws `Error` when `digits` is not an integer in `[0, 100]`.
-* @example
-* ```ts
-* Calc.serialize(Calc.of(1 / 3), { precision: Precision.decimals(2) }) // '0.33'
-* ```
-* @since 0.1.0
-*/
-const decimals = decimals$1;
-/**
-* Creates a `Precision` fixing the count of significant digits. Use it for
-* unit-free constants whose error is amplified downstream — solved curve
-* coefficients, for example — where fixed decimal places would truncate.
-*
-* @param digits - Significant digits. Must be an integer in `[1, 100]`.
-* @returns A `Precision` in `significant` mode.
-* @throws `Error` when `digits` is not an integer in `[1, 100]`.
-* @example
-* ```ts
-* const k = Calc.of(0.8377580409572781, Precision.significant(10))
-* Calc.serialize(k) // '0.837758041'
-* ```
-* @since 0.1.0
-*/
-const significant = significant$1;
-//#endregion
+import { r as calc_exports, t as precision_exports } from "../shared/calc-Cih4o2r7.mjs";
 export { calc_exports as Calc, precision_exports as Precision };
-
-//# sourceMappingURL=index.mjs.map