fashionable 0.2.0 → 0.4.0

package/dist/shared/declaration-CqRm38oZ.d.mts

@@ -0,0 +1,264 @@
+import { t as Pipeable } from "./utils-DpN6qr94.mjs";
+import { C as Any$1, E as None, c as Name, h as Color, i as PartialBindings, k as Precision, l as Var, n as Bindings, r as Calc, s as Any, t as ApplyBindings, w as Family } from "./index-D-hVWDgZ.mjs";
+import { n as RenderOptions$1 } from "./mediaQuery-VDIAHnM1.mjs";
+//#region src/declaration/declaration.internal.d.ts
+declare const DeclarationTypeId: unique symbol;
+type DeclarationTypeId = typeof DeclarationTypeId;
+declare namespace declaration_d_exports {
+  export { Declaration, Read, RenderOptions, Value, ValueFallback, bind, equals, isDeclaration, make, render, vars };
+}
+/**
+ * A CSS declaration: a property name paired with a value.
+ *
+ * This is the seam where the library's two halves meet — the value is
+ * either literal CSS text, passed through verbatim, or a value-layer
+ * expression (`Calc` or `Color`) serialized when the declaration renders.
+ * A `Calc` of any dimension is accepted: a `<number>`, or a `<length>` /
+ * `<angle>` built from `fashionable/data`, which carries its own units.
+ *
+ * The `Vars` parameter carries the value's unbound reads, as on `Calc`;
+ * literal text binds nothing and a text-valued declaration is a
+ * `Declaration<never>`. A whole-value custom-property read is spelled as a
+ * `Var` value, not literal text, so it joins the report:
+ * `make('font-family', Var.of('stack'))` is a `Declaration<Var<'stack'>>`.
+ *
+ * Construct via `make`.
+ *
+ * @since 0.1.0
+ */
+interface Declaration<out Vars extends Any = Any> extends Pipeable {
+  readonly [DeclarationTypeId]: DeclarationTypeId;
+  /**
+   * The property name, exactly as it renders — `font-size`, or `--depth`
+   * for a custom property.
+   */
+  readonly name: string;
+  /**
+   * The declaration's value: literal CSS text or a value-layer expression.
+   */
+  readonly value: Value<Vars>;
+}
+/**
+ * The fallbacks a declaration-level read admits: any declaration value —
+ * literal text, a number, an expression of either world, or another read,
+ * recursively. This is the widest projection of the generic fallback slot
+ * on `Var`: at the declaration level a fallback is an arbitrary token
+ * sequence, so every value form qualifies.
+ *
+ * @since 0.4.0
+ */
+type ValueFallback = string | number | Calc<Any, Any$1, unknown> | Color<Any> | Var<string, unknown, ValueFallback | undefined>;
+/**
+ * A custom-property read usable as a whole declaration value: bare, or
+ * carrying any declaration value as its fallback.
+ *
+ * @since 0.4.0
+ */
+type Read = Var<string, unknown, ValueFallback | undefined>;
+/**
+ * The value forms a declaration can hold: literal CSS text, a `Calc`
+ * expression of any dimension, a `Color` expression, or a whole-value
+ * custom-property read (`font-family: var(--stack, sans-serif)`), whose
+ * fallback may be any declaration value.
+ *
+ * @since 0.1.0
+ */
+type Value<Vars extends Any = Any> = string | Calc<Vars, Any$1, unknown> | Color<Vars> | Var<Name<Vars>, unknown, ValueFallback | undefined>;
+type ReadVars<V> = V extends Var<infer N, infer T, infer F> ? Var<N, T> | ReadFallbackVars<F> : never;
+type ReadFallbackVars<F> = F extends Calc<infer W, Any$1, unknown> ? W : F extends Color<infer W> ? W : F extends Any ? ReadVars<F> : never;
+/**
+ * Checks if a value is a `Declaration`.
+ *
+ * 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 `Declaration`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isDeclaration: (u: unknown) => u is Declaration<Any>;
+/**
+ * A handle usable in name position: a bare (fallback-free) read, written
+ * as its property (`make(gap, ...)` renders `--gap: ...`). A fallback
+ * belongs to a read site, so a fallback-carrying read is rejected
+ * structurally here.
+ *
+ * @since 0.4.0
+ */
+type Handle<T = unknown> = Var<string, T, undefined>;
+type DeclaredWrite<T, V2 extends Any> = T extends Color<Any> ? Color<V2> | string : T extends Calc<Any, infer R, unknown> ? Calc<V2, Family<R>, unknown> | ([Family<R>] extends [None] ? number : never) | string : never;
+type UndeclaredGuard<H> = H extends Var<string, infer T, undefined> ? [unknown] extends [T] ? unknown : "a declared handle types its write: pass a value of the handle's declared type" : never;
+declare const make: {
+  /**
+   * Creates a declaration whose value is a whole custom-property read —
+   * the honest spelling of `font-family: var(--stack, sans-serif)`, which
+   * as literal text would drop the read from the dependency report. The
+   * declaration's `Vars` unions the read's identity with its fallback
+   * chain's, flattened.
+   *
+   * @param name - The property name, exactly as it renders. Must be non-empty.
+   * @param value - The read, from `Var.of` (optionally through `Var.fallback`).
+   * @returns A `Declaration` carrying the read's names.
+   * @throws `Error` when `name` is empty, or the read's fallback chain holds a value no declaration can (anything but text, numbers, expressions, and reads).
+   * @example
+   * ```ts
+   * Declaration.make('font-family', Var.of('stack').pipe(Var.fallback('sans-serif')))
+   * // renders 'font-family: var(--stack, sans-serif);'
+   * ```
+   * @since 0.4.0
+   */
+  <V extends Read>(name: string, value: V): Declaration<ReadVars<V>>;
+  /**
+   * Creates a declaration.
+   *
+   * Literal text is stored verbatim — no parsing, no escaping. A bare
+   * number is coerced to an unannotated constant expression, as anywhere
+   * else an expression is accepted, so it serializes under the precision
+   * context rather than as raw text.
+   *
+   * @param name - The property name, exactly as it renders (`--x` keeps its dashes). Must be non-empty.
+   * @param value - Literal CSS text, a number, or a `Calc`/`Color` expression.
+   * @returns A `Declaration` carrying the value's variable names — `Declaration<never>` for text and numbers.
+   * @throws `Error` when `name` is empty, or `value` is a non-finite number.
+   * @example
+   * ```ts
+   * Declaration.make('color', 'red')
+   * Declaration.make('--fluid', Calc.add(14, Calc.multiply(Calc.var('vw'), 0.01)))
+   * ```
+   * @since 0.1.0
+   */
+  <Vars extends Any = never>(name: string, value: Value<Vars> | number): Declaration<Vars>;
+  /**
+   * Writes a property through its handle with a read as the whole value —
+   * the alias pattern, `--gap: var(--spacing)`. The read's names join the
+   * report; the written property contributes none (writing is not
+   * reading).
+   *
+   * @param handle - The property's canonical handle. Must be fallback-free.
+   * @param value - The read to write, from `Var.of` or a typed constructor (optionally through `Var.fallback`).
+   * @returns A `Declaration` carrying the read's names.
+   * @throws `Error` when the handle carries a fallback, or the value's fallback chain holds a form no declaration can.
+   * @since 0.4.0
+   */
+  <V extends Read>(handle: Handle, value: V): Declaration<ReadVars<V>>;
+  /**
+   * Writes a declared property through its handle, the value typed by the
+   * declared type: a `Var.length` handle takes length-family expressions
+   * (or literal text), a `Var.color` handle takes colors — so a write
+   * that contradicts the registration is a type error at the declaration.
+   * The name renders with its `--` prefix.
+   *
+   * @param handle - The property's canonical handle, from a typed `Var` constructor. Must be fallback-free.
+   * @param value - The value to write, typed by the handle's declared type; its own reads become the declaration's `Vars`.
+   * @returns A `Declaration` carrying the value's names.
+   * @throws `Error` when the handle carries a fallback.
+   * @example
+   * ```ts
+   * const gap = Var.length('gap')
+   * Declaration.render(Declaration.make(gap, Length.px(8))) // '--gap: 8px;'
+   * ```
+   * @since 0.4.0
+   */
+  <T extends Calc<Any, Any$1, unknown> | Color<Any>, V2 extends Any = never>(handle: Handle<T>, value: DeclaredWrite<T, V2>): Declaration<V2>;
+  /**
+   * Writes a property through its undeclared handle: any declaration
+   * value, exactly as the string-name form. The name renders with its
+   * `--` prefix.
+   *
+   * @param handle - The property's canonical handle, from `Var.of`. Must be fallback-free.
+   * @param value - Literal CSS text, a number, or a `Calc`/`Color` expression.
+   * @returns A `Declaration` carrying the value's names.
+   * @throws `Error` when the handle carries a fallback.
+   * @since 0.4.0
+   */
+  <H extends Handle, V2 extends Any = never>(handle: H & UndeclaredGuard<H>, value: Value<V2> | number): Declaration<V2>;
+};
+declare const bind: {
+  /**
+   * Returns a function that binds the given names in a declaration's
+   * value.
+   *
+   * @param bindings - Variable names to values or expressions.
+   * @returns A function replacing bound variables in its argument's value.
+   * @since 0.1.0
+   */
+  <const B extends Bindings>(bindings: B): <Vars extends Any>(declaration: Declaration<Vars>) => Declaration<ApplyBindings<Vars, B>>;
+  /**
+   * Replaces variables in the declaration's value with values or other
+   * expressions, re-folding constant subtrees. Semantics match
+   * `Calc.bind`: unread names and `undefined` values are ignored, and
+   * expression-valued bindings contribute their own variables. A
+   * literal-text value binds nothing; the declaration is returned as-is.
+   *
+   * @param declaration - The declaration to bind.
+   * @param bindings - Variable names to values or expressions.
+   * @returns The bound declaration.
+   * @since 0.1.0
+   */
+  <Vars extends Any, const B extends PartialBindings<Vars>>(declaration: Declaration<Vars>, bindings: B): Declaration<ApplyBindings<Vars, B>>;
+};
+/**
+ * The declaration's unbound variable names — empty for literal text,
+ * the value's variables otherwise.
+ *
+ * @param declaration - The declaration to inspect.
+ * @returns The set of unbound variable names.
+ * @since 0.1.0
+ */
+declare const vars: <Vars extends Any>(declaration: Declaration<Vars>) => ReadonlySet<Name<Vars>>;
+/**
+ * Options for `render`, extending `MediaQuery.RenderOptions` — the
+ * render-options family's base — with the precision context.
+ *
+ * @since 0.1.0
+ */
+interface RenderOptions extends RenderOptions$1 {
+  /**
+   * The precision for expression constants that carry no annotation of
+   * their own. Defaults to `Precision.decimals(5)`, as in
+   * `Calc.serialize`.
+   */
+  readonly precision?: Precision;
+}
+/**
+ * Renders the declaration as one CSS declaration, semicolon included:
+ * `name: value;`. Literal text passes through verbatim; expression
+ * values serialize as `Calc.serialize`/`Color.serialize` would, with
+ * unbound variables rendering as `var(--name)`.
+ *
+ * @param declaration - The declaration to render.
+ * @param options - Optional precision context for expression values.
+ * @returns Deterministic CSS text.
+ * @example
+ * ```ts
+ * Declaration.render(Declaration.make('--indent', Calc.multiply(Calc.var('depth'), 8)))
+ * // '--indent: calc(var(--depth) * 8);'
+ * ```
+ * @since 0.1.0
+ */
+declare const render: (declaration: Declaration<Any>, options?: RenderOptions) => string;
+declare const equals: {
+  /**
+   * Returns a function that checks structural equality against `that`.
+   *
+   * @param that - The declaration to compare against.
+   * @returns A function testing its argument for structural equality with `that`.
+   * @since 0.1.0
+   */
+  (that: Declaration<Any>): (self: Declaration<Any>) => boolean;
+  /**
+   * Structural equality: names compare as text, expression values as
+   * expression trees (`Calc.equals` semantics, precision annotations
+   * included). Literal text never equals an expression, even one that
+   * would serialize to the same characters.
+   *
+   * @param self - The first declaration.
+   * @param that - The second declaration.
+   * @returns `true` if the declarations are structurally equal.
+   * @since 0.1.0
+   */
+  (self: Declaration<Any>, that: Declaration<Any>): boolean;
+};
+//#endregion
+export { RenderOptions as n, declaration_d_exports as r, Declaration as t };
+//# sourceMappingURL=declaration-CqRm38oZ.d.mts.map

package/dist/shared/declaration.internal-bHzvbanA.mjs

@@ -0,0 +1,121 @@
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { a as hash, i as equals$1, n as HashTypeId, r as combine, s as hashString, t as EqualTypeId } from "./equal-U9G5LhtL.mjs";
+import { a as fallback, g as EMPTY_REFS, o as fallbackOf, s as isVar, u as nameOf, v as refsOf$1 } from "./var.internal-DSxAzEFN.mjs";
+import { S as toCalc, c as bind$1, p as isCalc, y as serialize } from "./calc-Uwbxd7CS.mjs";
+import { a as isColor, p as serialize$1, t as bind$2 } from "./color.internal-CxjlaRqR.mjs";
+//#region src/declaration/declaration.internal.ts
+const DeclarationTypeId = Symbol.for("fashionable/declaration");
+const valueEquals = (a, b) => typeof a === "string" || typeof b === "string" ? a === b : equals$1(a, b);
+const valueHash = (value) => typeof value === "string" ? hashString(value) : hash(value);
+const serializeFallback = (fb, precision) => {
+	if (typeof fb === "string") return fb;
+	const options = precision === void 0 ? {} : { precision };
+	if (typeof fb === "number" || isCalc(fb)) return serialize(toCalc(fb), options);
+	if (isVar(fb)) return serializeRead(fb, precision);
+	return serialize$1(fb, options);
+};
+const serializeRead = (read, precision) => {
+	const fb = fallbackOf(read);
+	return fb === void 0 ? `var(--${nameOf(read)})` : `var(--${nameOf(read)}, ${serializeFallback(fb, precision)})`;
+};
+const serializeValue = (value, precision) => {
+	if (typeof value === "string") return value;
+	if (isVar(value)) return serializeRead(value, precision);
+	const options = precision === void 0 ? {} : { precision };
+	return isCalc(value) ? serialize(value, options) : serialize$1(value, options);
+};
+var DeclarationImpl = class extends Pipeable {
+	[DeclarationTypeId] = DeclarationTypeId;
+	name;
+	value;
+	refSet;
+	#hash;
+	constructor(name, value) {
+		super();
+		this.name = name;
+		this.value = value;
+		this.refSet = typeof value === "string" ? EMPTY_REFS : refsOf$1(value);
+	}
+	[EqualTypeId](that) {
+		return isDeclaration(that) && this.name === that.name && valueEquals(this.value, that.value);
+	}
+	[HashTypeId]() {
+		if (this.#hash === void 0) {
+			let h = hashString("fashionable/declaration");
+			h = combine(h, hashString(this.name));
+			h = combine(h, valueHash(this.value));
+			this.#hash = h;
+		}
+		return this.#hash;
+	}
+	get [Symbol.toStringTag]() {
+		return `Declaration(${this.name}: ${serializeValue(this.value)})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+/** @internal */
+const isDeclaration = (u) => typeof u === "object" && u !== null && DeclarationTypeId in u;
+/** @internal */
+const refsOf = (declaration) => declaration.refSet;
+const validateReadFallback = (fb) => {
+	if (fb === void 0 || typeof fb === "string" || typeof fb === "number") return;
+	if (isVar(fb)) {
+		validateReadFallback(fallbackOf(fb));
+		return;
+	}
+	invariant(isCalc(fb) || isColor(fb), "Declaration var fallback must be text, a number, an expression, or a Var read");
+};
+/** @internal */
+function make(name, value) {
+	let resolved;
+	if (isVar(name)) {
+		invariant(fallbackOf(name) === void 0, "A write takes the bare handle — a fallback belongs to a read site, not the property");
+		resolved = `--${nameOf(name)}`;
+	} else resolved = name;
+	invariant(resolved.length > 0, "Declaration name must be a non-empty string");
+	if (isVar(value)) validateReadFallback(fallbackOf(value));
+	return new DeclarationImpl(resolved, typeof value === "number" ? toCalc(value) : value);
+}
+const bindRead = (read, bindings) => {
+	const bound = bindings[nameOf(read)];
+	if (bound !== void 0) return toCalc(bound);
+	const fb = fallbackOf(read);
+	const rebound = bindFallback(fb, bindings);
+	return rebound === fb ? read : fallback(read, rebound);
+};
+const bindFallback = (fb, bindings) => {
+	if (fb === void 0 || typeof fb === "string" || typeof fb === "number") return fb;
+	if (isCalc(fb)) return bind$1(fb, bindings);
+	if (isVar(fb)) return bindRead(fb, bindings);
+	return bind$2(fb, bindings);
+};
+/** @internal */
+const bind = dual(2, (declaration, bindings) => {
+	const value = declaration.value;
+	if (typeof value === "string") return declaration;
+	if (isVar(value)) {
+		let touchesRead = false;
+		for (const name of refsOf$1(value)) if (bindings[name] !== void 0) {
+			touchesRead = true;
+			break;
+		}
+		return touchesRead ? new DeclarationImpl(declaration.name, bindRead(value, bindings)) : declaration;
+	}
+	return new DeclarationImpl(declaration.name, isCalc(value) ? bind$1(value, bindings) : bind$2(value, bindings));
+});
+/** @internal */
+function refs(declaration) {
+	return refsOf(declaration);
+}
+/** @internal */
+const renderWith = (declaration, precision) => `${declaration.name}: ${serializeValue(declaration.value, precision)};`;
+/** @internal */
+const render = (declaration, options) => renderWith(declaration, options?.precision);
+/** @internal */
+const equals = dual(2, (self, that) => equals$1(self, that));
+//#endregion
+export { refs as a, renderWith as c, make as i, equals as n, refsOf as o, isDeclaration as r, render as s, bind as t };
+
+//# sourceMappingURL=declaration.internal-bHzvbanA.mjs.map

package/dist/shared/declaration.internal-bHzvbanA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.internal-bHzvbanA.mjs","names":["Equal.equals","Equal.hashString","Equal.hash","serializeCalc","serializeColor","varNameOf","protocolRefsOf","Equal.EqualTypeId","Equal.HashTypeId","#hash","Equal.combine","deriveRead","bindCalc","bindColor"],"sources":["../../src/declaration/declaration.internal.ts"],"sourcesContent":["import type { ApplyBindings, Bindings, Input } from '#calc/calc'\nimport { bind as bindCalc, isCalc, serialize as serializeCalc, toCalc } from '#calc/calc.internal'\nimport type { Precision } from '#calc/precision'\nimport { bind as bindColor, isColor, serialize as serializeColor } from '#data/color.internal'\nimport * as Equal from '#internal/equal'\nimport { EMPTY_REFS, refsOf as protocolRefsOf } from '#internal/refs'\nimport { dual, invariant, Pipeable } from '#util'\nimport type { Name as VarName } from '#var/var'\nimport {\n  type AnyVar,\n  fallback as deriveRead,\n  fallbackOf,\n  isVar,\n  nameOf as varNameOf,\n} from '#var/var.internal'\nimport type { Declaration, RenderOptions, Value } from './declaration.ts'\n\nexport const DeclarationTypeId = Symbol.for('fashionable/declaration')\nexport type DeclarationTypeId = typeof DeclarationTypeId\n\nconst valueEquals = (a: Value<AnyVar>, b: Value<AnyVar>): boolean =>\n  typeof a === 'string' || typeof b === 'string' ? a === b : Equal.equals(a, b)\n\nconst valueHash = (value: Value<AnyVar>): number =>\n  typeof value === 'string' ? Equal.hashString(value) : Equal.hash(value)\n\n// A declaration-level fallback renders by its own form: literal text\n// verbatim, numbers as constants under the precision context, expressions\n// through their serializers, nested reads recursively.\nconst serializeFallback = (fb: unknown, precision?: Precision): string => {\n  if (typeof fb === 'string') {\n    return fb\n  }\n  const options = precision === undefined ? {} : { precision }\n  if (typeof fb === 'number' || isCalc(fb)) {\n    return serializeCalc(toCalc(fb as number), options)\n  }\n  if (isVar(fb)) {\n    return serializeRead(fb, precision)\n  }\n  return serializeColor(fb as Parameters<typeof serializeColor>[0], options)\n}\n\nconst serializeRead = (read: AnyVar, precision?: Precision): string => {\n  const fb = fallbackOf(read)\n  return fb === undefined\n    ? `var(--${varNameOf(read)})`\n    : `var(--${varNameOf(read)}, ${serializeFallback(fb, precision)})`\n}\n\nconst serializeValue = (value: Value<AnyVar>, precision?: Precision): string => {\n  if (typeof value === 'string') {\n    return value\n  }\n  if (isVar(value)) {\n    return serializeRead(value, precision)\n  }\n  const options = precision === undefined ? {} : { precision }\n  return isCalc(value) ? serializeCalc(value, options) : serializeColor(value, options)\n}\n\nclass DeclarationImpl extends Pipeable implements Declaration<AnyVar>, Equal.Equal {\n  readonly [DeclarationTypeId]: DeclarationTypeId = DeclarationTypeId\n\n  readonly name: string\n  readonly value: Value<AnyVar>\n  readonly refSet: ReadonlySet<string>\n  #hash: number | undefined\n\n  constructor(name: string, value: Value<AnyVar>) {\n    super()\n    this.name = name\n    this.value = value\n    // the refs protocol covers every non-text form uniformly: Calc, Color,\n    // and Var values each expose their vars set behind the shared symbol\n    this.refSet = typeof value === 'string' ? EMPTY_REFS : protocolRefsOf(value)\n  }\n\n  [Equal.EqualTypeId](that: unknown): boolean {\n    return isDeclaration(that) && this.name === that.name && valueEquals(this.value, that.value)\n  }\n\n  [Equal.HashTypeId](): number {\n    if (this.#hash === undefined) {\n      let h = Equal.hashString('fashionable/declaration')\n      h = Equal.combine(h, Equal.hashString(this.name))\n      h = Equal.combine(h, valueHash(this.value))\n      this.#hash = h\n    }\n    return this.#hash\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Declaration(${this.name}: ${serializeValue(this.value)})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\n/** @internal */\nexport const isDeclaration = (u: unknown): u is Declaration<AnyVar> =>\n  typeof u === 'object' && u !== null && DeclarationTypeId in u\n\n/** @internal */\nexport const refsOf = (declaration: Declaration<AnyVar>): ReadonlySet<string> =>\n  (declaration as unknown as DeclarationImpl).refSet\n\n// A read's fallback chain must hold declaration-value forms only. The\n// public signatures enforce this; the walk backs them for untyped callers.\nconst validateReadFallback = (fb: unknown): void => {\n  if (fb === undefined || typeof fb === 'string' || typeof fb === 'number') {\n    return\n  }\n  if (isVar(fb)) {\n    validateReadFallback(fallbackOf(fb))\n    return\n  }\n  invariant(\n    isCalc(fb) || isColor(fb),\n    'Declaration var fallback must be text, a number, an expression, or a Var read',\n  )\n}\n\n/** @internal */\nexport function make(name: string | AnyVar, value: Value<AnyVar> | number): Declaration<never> {\n  let resolved: string\n  if (isVar(name)) {\n    invariant(\n      fallbackOf(name) === undefined,\n      'A write takes the bare handle — a fallback belongs to a read site, not the property',\n    )\n    resolved = `--${varNameOf(name)}`\n  } else {\n    resolved = name\n  }\n  invariant(resolved.length > 0, 'Declaration name must be a non-empty string')\n  if (isVar(value)) {\n    validateReadFallback(fallbackOf(value))\n  }\n  return new DeclarationImpl(\n    resolved,\n    typeof value === 'number' ? toCalc(value) : value,\n  ) as Declaration<never>\n}\n\n// Binding a read: a bound name replaces the whole read (fallback\n// discarded, as in calc), an unbound one keeps the read and binds inside\n// its fallback chain instead.\nconst bindRead = (read: AnyVar, bindings: Record<string, Input>): Value<AnyVar> => {\n  const bound = bindings[varNameOf(read)]\n  if (bound !== undefined) {\n    return toCalc(bound)\n  }\n  const fb = fallbackOf(read)\n  const rebound = bindFallback(fb, bindings)\n  return rebound === fb ? (read as Value<AnyVar>) : (deriveRead(read, rebound) as Value<AnyVar>)\n}\n\nconst bindFallback = (fb: unknown, bindings: Record<string, Input>): unknown => {\n  if (fb === undefined || typeof fb === 'string' || typeof fb === 'number') {\n    return fb\n  }\n  if (isCalc(fb)) {\n    return bindCalc(fb, bindings)\n  }\n  if (isVar(fb)) {\n    return bindRead(fb, bindings)\n  }\n  return bindColor(fb as Parameters<typeof bindColor>[0], bindings)\n}\n\n/** @internal */\nexport const bind: {\n  <const B extends Bindings>(\n    bindings: B,\n  ): <Vars extends AnyVar>(declaration: Declaration<Vars>) => Declaration<ApplyBindings<Vars, B>>\n  <Vars extends AnyVar, const B extends Bindings>(\n    declaration: Declaration<Vars>,\n    bindings: B,\n  ): Declaration<ApplyBindings<Vars, B>>\n} = dual(\n  2,\n  (declaration: Declaration<AnyVar>, bindings: Record<string, Input>): Declaration<AnyVar> => {\n    const value = declaration.value\n    if (typeof value === 'string') {\n      return declaration\n    }\n    if (isVar(value)) {\n      let touchesRead = false\n      for (const name of protocolRefsOf(value)) {\n        if (bindings[name] !== undefined) {\n          touchesRead = true\n          break\n        }\n      }\n      return touchesRead\n        ? new DeclarationImpl(declaration.name, bindRead(value, bindings))\n        : declaration\n    }\n    return new DeclarationImpl(\n      declaration.name,\n      isCalc(value) ? bindCalc(value, bindings) : bindColor(value, bindings),\n    )\n  },\n)\n\n/** @internal */\nexport function refs<Vars extends AnyVar>(\n  declaration: Declaration<Vars>,\n): ReadonlySet<VarName<Vars>> {\n  return refsOf(declaration) as ReadonlySet<VarName<Vars>>\n}\n\n/** @internal */\nexport const renderWith = (declaration: Declaration<AnyVar>, precision?: Precision): string =>\n  `${declaration.name}: ${serializeValue(declaration.value, precision)};`\n\n/** @internal */\nexport const render = (declaration: Declaration<AnyVar>, options?: RenderOptions): string =>\n  renderWith(declaration, options?.precision)\n\n/** @internal */\nexport const equals = dual<\n  (that: Declaration<AnyVar>) => (self: Declaration<AnyVar>) => boolean,\n  (self: Declaration<AnyVar>, that: Declaration<AnyVar>) => boolean\n>(2, (self: Declaration<AnyVar>, that: Declaration<AnyVar>): boolean => Equal.equals(self, that))\n"],"mappings":"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"}

package/dist/shared/{fontFaceRule-C7nYgH6X.d.mts → fontFaceRule-BOgUM4PF.d.mts}

@@ -1,5 +1,5 @@
-import { t as Pipeable } from "./utils-BKm298I-.mjs";
-import { n as RenderOptions$1 } from "./declaration-1DlO_ltT.mjs";
+import { t as Pipeable } from "./utils-DpN6qr94.mjs";
+import { n as RenderOptions$1 } from "./declaration-CqRm38oZ.mjs";
 //#region src/fontFace/fontFaceRule.internal.d.ts
 declare const FontFaceRuleTypeId: unique symbol;
 type FontFaceRuleTypeId = typeof FontFaceRuleTypeId;
@@ -291,4 +291,4 @@ declare const equals: {
 };
 //#endregion
 export { fontFaceRule_d_exports as n, FontFaceRule as t };
-//# sourceMappingURL=fontFaceRule-C7nYgH6X.d.mts.map
+//# sourceMappingURL=fontFaceRule-BOgUM4PF.d.mts.map