fashionable 0.0.0 → 0.2.0

package/dist/shared/declaration-1DlO_ltT.d.mts

@@ -0,0 +1,166 @@
+import { a as Kind, c as Precision, n as Bindings, r as Calc, t as ApplyBindings } from "./index-BvtwY4FQ.mjs";
+import { t as Pipeable } from "./utils-BKm298I-.mjs";
+import { t as Color } from "./color-BvNJ2YqL.mjs";
+import { n as RenderOptions$1 } from "./mediaQuery-BYR1z-iD.mjs";
+//#region src/declaration/declaration.internal.d.ts
+declare const DeclarationTypeId: unique symbol;
+type DeclarationTypeId = typeof DeclarationTypeId;
+declare namespace declaration_d_exports {
+  export { Declaration, RenderOptions, Value, bind, equals, isDeclaration, make, refs, render };
+}
+/**
+ * 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 `Refs` parameter carries the value's unbound reference names, as on
+ * `Calc`; literal text binds nothing and a text-valued declaration is a
+ * `Declaration<never>`.
+ *
+ * Construct via `make`.
+ *
+ * @since 0.1.0
+ */
+interface Declaration<out Refs extends string = string> 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<Refs>;
+}
+/**
+ * The value forms a declaration can hold: literal CSS text, a `Calc`
+ * expression of any dimension, or a `Color` expression.
+ *
+ * @since 0.1.0
+ */
+type Value<Refs extends string = string> = string | Calc<Refs, Kind, unknown> | Color<Refs>;
+/**
+ * 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<string>;
+/**
+ * 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 reference 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.ref('vw'), 0.01)))
+ * ```
+ * @since 0.1.0
+ */
+declare const make: <Refs extends string = never>(name: string, value: Value<Refs> | number) => Declaration<Refs>;
+declare const bind: {
+  /**
+   * Returns a function that binds the given names in a declaration's
+   * value.
+   *
+   * @param bindings - Reference names to values or expressions.
+   * @returns A function replacing bound references in its argument's value.
+   * @since 0.1.0
+   */
+  <const B extends Bindings>(bindings: B): <Refs extends string>(declaration: Declaration<Refs>) => Declaration<ApplyBindings<Refs, B>>;
+  /**
+   * Replaces references in the declaration's value with values or other
+   * expressions, re-folding constant subtrees. Semantics match
+   * `Calc.bind`: unreferenced names and `undefined` values are ignored,
+   * and expression-valued bindings contribute their own references. A
+   * literal-text value binds nothing; the declaration is returned as-is.
+   *
+   * @param declaration - The declaration to bind.
+   * @param bindings - Reference names to values or expressions.
+   * @returns The bound declaration.
+   * @since 0.1.0
+   */
+  <Refs extends string, const B extends Bindings>(declaration: Declaration<Refs>, bindings: B): Declaration<ApplyBindings<Refs, B>>;
+};
+/**
+ * The declaration's unbound reference names — empty for literal text,
+ * the value's references otherwise.
+ *
+ * @param declaration - The declaration to inspect.
+ * @returns The set of unbound reference names.
+ * @since 0.1.0
+ */
+declare const refs: <Refs extends string>(declaration: Declaration<Refs>) => ReadonlySet<Refs>;
+/**
+ * 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 references 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.ref('depth'), 8)))
+ * // '--indent: calc(var(--depth) * 8);'
+ * ```
+ * @since 0.1.0
+ */
+declare const render: (declaration: Declaration<string>, 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<string>): (self: Declaration<string>) => 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<string>, that: Declaration<string>): boolean;
+};
+//#endregion
+export { RenderOptions as n, declaration_d_exports as r, Declaration as t };
+//# sourceMappingURL=declaration-1DlO_ltT.d.mts.map

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

@@ -0,0 +1,73 @@
+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 { C as EMPTY_REFS, S as toCalc, c as bind$1, p as isCalc, v as refsOf$1, y as serialize } from "./calc-Cih4o2r7.mjs";
+import { f as refsOf$2, p as serialize$1, t as bind$2 } from "./color.internal-Dts5ycTm.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 serializeValue = (value, precision) => {
+	if (typeof value === "string") return value;
+	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 : isCalc(value) ? refsOf$1(value) : refsOf$2(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;
+/** @internal */
+function make(name, value) {
+	invariant(name.length > 0, "Declaration name must be a non-empty string");
+	return new DeclarationImpl(name, typeof value === "number" ? toCalc(value) : value);
+}
+/** @internal */
+const bind = dual(2, (declaration, bindings) => {
+	const value = declaration.value;
+	if (typeof value === "string") return 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-wLB4ssxC.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.internal-wLB4ssxC.mjs","names":["Equal.equals","Equal.hashString","Equal.hash","serializeCalc","serializeColor","calcRefsOf","colorRefsOf","Equal.EqualTypeId","Equal.HashTypeId","#hash","Equal.combine","bindCalc","bindColor"],"sources":["../../src/declaration/declaration.internal.ts"],"sourcesContent":["import type { ApplyBindings, Bindings, Input } from '#calc/calc'\nimport {\n  bind as bindCalc,\n  isCalc,\n  refsOf as calcRefsOf,\n  serialize as serializeCalc,\n  toCalc,\n} from '#calc/calc.internal'\nimport type { Precision } from '#calc/precision'\nimport {\n  bind as bindColor,\n  refsOf as colorRefsOf,\n  serialize as serializeColor,\n} from '#data/color.internal'\nimport * as Equal from '#internal/equal'\nimport { EMPTY_REFS } from '#internal/refs'\nimport { dual, invariant, Pipeable } from '#util'\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<string>, b: Value<string>): boolean =>\n  typeof a === 'string' || typeof b === 'string' ? a === b : Equal.equals(a, b)\n\nconst valueHash = (value: Value<string>): number =>\n  typeof value === 'string' ? Equal.hashString(value) : Equal.hash(value)\n\nconst serializeValue = (value: Value<string>, precision?: Precision): string => {\n  if (typeof value === 'string') {\n    return value\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<string>, Equal.Equal {\n  readonly [DeclarationTypeId]: DeclarationTypeId = DeclarationTypeId\n\n  readonly name: string\n  readonly value: Value<string>\n  readonly refSet: ReadonlySet<string>\n  #hash: number | undefined\n\n  constructor(name: string, value: Value<string>) {\n    super()\n    this.name = name\n    this.value = value\n    this.refSet =\n      typeof value === 'string'\n        ? EMPTY_REFS\n        : isCalc(value)\n          ? calcRefsOf(value)\n          : colorRefsOf(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<string> =>\n  typeof u === 'object' && u !== null && DeclarationTypeId in u\n\n/** @internal */\nexport const refsOf = <R extends string>(declaration: Declaration<R>): ReadonlySet<R> =>\n  (declaration as unknown as DeclarationImpl).refSet as ReadonlySet<R>\n\n/** @internal */\nexport function make<Refs extends string = never>(\n  name: string,\n  value: Value<Refs> | number,\n): Declaration<Refs> {\n  invariant(name.length > 0, 'Declaration name must be a non-empty string')\n  return new DeclarationImpl(\n    name,\n    typeof value === 'number' ? toCalc(value) : value,\n  ) as Declaration<Refs>\n}\n\n/** @internal */\nexport const bind: {\n  <const B extends Bindings>(\n    bindings: B,\n  ): <Refs extends string>(declaration: Declaration<Refs>) => Declaration<ApplyBindings<Refs, B>>\n  <Refs extends string, const B extends Bindings>(\n    declaration: Declaration<Refs>,\n    bindings: B,\n  ): Declaration<ApplyBindings<Refs, B>>\n} = dual(\n  2,\n  (\n    declaration: Declaration<string>,\n    bindings: Record<string, Input<string>>,\n  ): Declaration<string> => {\n    const value = declaration.value\n    if (typeof value === 'string') {\n      return 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<Refs extends string>(declaration: Declaration<Refs>): ReadonlySet<Refs> {\n  return refsOf(declaration)\n}\n\n/** @internal */\nexport const renderWith = (declaration: Declaration<string>, precision?: Precision): string =>\n  `${declaration.name}: ${serializeValue(declaration.value, precision)};`\n\n/** @internal */\nexport const render = (declaration: Declaration<string>, options?: RenderOptions): string =>\n  renderWith(declaration, options?.precision)\n\n/** @internal */\nexport const equals = dual<\n  (that: Declaration<string>) => (self: Declaration<string>) => boolean,\n  (self: Declaration<string>, that: Declaration<string>) => boolean\n>(2, (self: Declaration<string>, that: Declaration<string>): boolean => Equal.equals(self, that))\n"],"mappings":";;;;;AAmBA,MAAa,oBAAoB,OAAO,IAAI,yBAAyB;AAGrE,MAAM,eAAe,GAAkB,MACrC,OAAO,MAAM,YAAY,OAAO,MAAM,WAAW,MAAM,IAAIA,SAAa,GAAG,CAAC;AAE9E,MAAM,aAAa,UACjB,OAAO,UAAU,WAAWC,WAAiB,KAAK,IAAIC,KAAW,KAAK;AAExE,MAAM,kBAAkB,OAAsB,cAAkC;CAC9E,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,MAAM,UAAU,cAAc,KAAA,IAAY,CAAC,IAAI,EAAE,UAAU;CAC3D,OAAO,OAAO,KAAK,IAAIC,UAAc,OAAO,OAAO,IAAIC,YAAe,OAAO,OAAO;AACtF;AAEA,IAAM,kBAAN,cAA8B,SAAqD;CACjF,CAAU,qBAAwC;CAElD;CACA;CACA;CACA;CAEA,YAAY,MAAc,OAAsB;EAC9C,MAAM;EACN,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,KAAK,SACH,OAAO,UAAU,WACb,aACA,OAAO,KAAK,IACVC,SAAW,KAAK,IAChBC,SAAY,KAAK;CAC3B;CAEA,CAACC,aAAmB,MAAwB;EAC1C,OAAO,cAAc,IAAI,KAAK,KAAK,SAAS,KAAK,QAAQ,YAAY,KAAK,OAAO,KAAK,KAAK;CAC7F;CAEA,CAACC,cAA4B;EAC3B,IAAI,KAAKC,UAAU,KAAA,GAAW;GAC5B,IAAI,IAAIR,WAAiB,yBAAyB;GAClD,IAAIS,QAAc,GAAGT,WAAiB,KAAK,IAAI,CAAC;GAChD,IAAIS,QAAc,GAAG,UAAU,KAAK,KAAK,CAAC;GAC1C,KAAKD,QAAQ;EACf;EACA,OAAO,KAAKA;CACd;CAEA,KAAK,OAAO,eAAe;EACzB,OAAO,eAAe,KAAK,KAAK,IAAI,eAAe,KAAK,KAAK,EAAE;CACjE;CAEA,KAAK,OAAO,IAAI,4BAA4B,KAAK;EAC/C,OAAO,KAAK,OAAO;CACrB;AACF;;AAGA,MAAa,iBAAiB,MAC5B,OAAO,MAAM,YAAY,MAAM,QAAQ,qBAAqB;;AAG9D,MAAa,UAA4B,gBACtC,YAA2C;;AAG9C,SAAgB,KACd,MACA,OACmB;CACnB,UAAU,KAAK,SAAS,GAAG,6CAA6C;CACxE,OAAO,IAAI,gBACT,MACA,OAAO,UAAU,WAAW,OAAO,KAAK,IAAI,KAC9C;AACF;;AAGA,MAAa,OAQT,KACF,IAEE,aACA,aACwB;CACxB,MAAM,QAAQ,YAAY;CAC1B,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,OAAO,IAAI,gBACT,YAAY,MACZ,OAAO,KAAK,IAAIE,OAAS,OAAO,QAAQ,IAAIC,OAAU,OAAO,QAAQ,CACvE;AACF,CACF;;AAGA,SAAgB,KAA0B,aAAmD;CAC3F,OAAO,OAAO,WAAW;AAC3B;;AAGA,MAAa,cAAc,aAAkC,cAC3D,GAAG,YAAY,KAAK,IAAI,eAAe,YAAY,OAAO,SAAS,EAAE;;AAGvE,MAAa,UAAU,aAAkC,YACvD,WAAW,aAAa,SAAS,SAAS;;AAG5C,MAAa,SAAS,KAGpB,IAAI,MAA2B,SAAuCZ,SAAa,MAAM,IAAI,CAAC"}

package/dist/shared/equal-U9G5LhtL.mjs

@@ -0,0 +1,71 @@
+//#region src/internal/equal.ts
+/**
+* A minimal structural equality and hashing protocol, modeled on Effect-TS's
+* Equal and Hash modules but reduced to what this library needs: value types
+* implement the two symbol methods on their Impl classes, and `equals` uses
+* the hash as a fast-path reject before dispatching to the symbol method.
+*
+* The protocol is internal. Each public namespace exposes a typed `equals`
+* that delegates here.
+*/
+const EqualTypeId = Symbol.for("fashionable/Equal");
+const HashTypeId = Symbol.for("fashionable/Hash");
+/** @internal */
+const isEqual = (u) => typeof u === "object" && u !== null && EqualTypeId in u;
+/** @internal */
+const equals = (a, b) => {
+	if (a === b) return true;
+	if (isEqual(a) && isEqual(b)) {
+		if (a[HashTypeId]() !== b[HashTypeId]()) return false;
+		return a[EqualTypeId](b);
+	}
+	return false;
+};
+/** @internal */
+const hash = (u) => {
+	switch (typeof u) {
+		case "number": return hashNumber(u);
+		case "string": return hashString(u);
+		case "boolean": return u ? 1231 : 1237;
+		case "undefined": return -1640531527;
+		case "object":
+			if (u === null) return -2048144789;
+			if (isEqual(u)) return u[HashTypeId]();
+			return 0;
+		default: return 0;
+	}
+};
+/**
+* Combines two hashes into one, order-sensitively (boost hash_combine).
+*
+* @internal
+*/
+const combine = (a, b) => a ^ b + 2654435769 + (a << 6) + (a >>> 2) | 0;
+/**
+* FNV-1a over UTF-16 code units.
+*
+* @internal
+*/
+const hashString = (s) => {
+	let h = -2128831035;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h | 0;
+};
+const numberBits = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+/**
+* Hashes a number by its float64 bit pattern. Negative zero is normalized
+* to positive zero first so values that compare equal hash equally.
+*
+* @internal
+*/
+const hashNumber = (n) => {
+	numberBits.setFloat64(0, n === 0 ? 0 : n);
+	return combine(numberBits.getInt32(0), numberBits.getInt32(4));
+};
+//#endregion
+export { hash as a, equals as i, HashTypeId as n, hashNumber as o, combine as r, hashString as s, EqualTypeId as t };
+
+//# sourceMappingURL=equal-U9G5LhtL.mjs.map

package/dist/shared/equal-U9G5LhtL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal-U9G5LhtL.mjs","names":[],"sources":["../../src/internal/equal.ts"],"sourcesContent":["/**\n * A minimal structural equality and hashing protocol, modeled on Effect-TS's\n * Equal and Hash modules but reduced to what this library needs: value types\n * implement the two symbol methods on their Impl classes, and `equals` uses\n * the hash as a fast-path reject before dispatching to the symbol method.\n *\n * The protocol is internal. Each public namespace exposes a typed `equals`\n * that delegates here.\n */\n\nexport const EqualTypeId: unique symbol = Symbol.for('fashionable/Equal')\nexport type EqualTypeId = typeof EqualTypeId\n\nexport const HashTypeId: unique symbol = Symbol.for('fashionable/Hash')\nexport type HashTypeId = typeof HashTypeId\n\n/** @internal */\nexport interface Equal {\n  [EqualTypeId](that: unknown): boolean\n  [HashTypeId](): number\n}\n\n/** @internal */\nexport const isEqual = (u: unknown): u is Equal =>\n  typeof u === 'object' && u !== null && EqualTypeId in u\n\n/** @internal */\nexport const equals = (a: unknown, b: unknown): boolean => {\n  if (a === b) {\n    return true\n  }\n  if (isEqual(a) && isEqual(b)) {\n    if (a[HashTypeId]() !== b[HashTypeId]()) {\n      return false\n    }\n    return a[EqualTypeId](b)\n  }\n  return false\n}\n\n/** @internal */\nexport const hash = (u: unknown): number => {\n  switch (typeof u) {\n    case 'number':\n      return hashNumber(u)\n    case 'string':\n      return hashString(u)\n    case 'boolean':\n      return u ? 1231 : 1237\n    case 'undefined':\n      return 0x9e3779b9 | 0\n    case 'object':\n      if (u === null) {\n        return 0x85ebca6b | 0\n      }\n      if (isEqual(u)) {\n        return u[HashTypeId]()\n      }\n      return 0\n    default:\n      return 0\n  }\n}\n\n/**\n * Combines two hashes into one, order-sensitively (boost hash_combine).\n *\n * @internal\n */\nexport const combine = (a: number, b: number): number =>\n  (a ^ (b + 0x9e3779b9 + (a << 6) + (a >>> 2))) | 0\n\n/**\n * FNV-1a over UTF-16 code units.\n *\n * @internal\n */\nexport const hashString = (s: string): number => {\n  let h = 0x811c9dc5 | 0\n  for (let i = 0; i < s.length; i++) {\n    h ^= s.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return h | 0\n}\n\nconst numberBits = new DataView(new ArrayBuffer(8))\n\n/**\n * Hashes a number by its float64 bit pattern. Negative zero is normalized\n * to positive zero first so values that compare equal hash equally.\n *\n * @internal\n */\nexport const hashNumber = (n: number): number => {\n  numberBits.setFloat64(0, n === 0 ? 0 : n)\n  return combine(numberBits.getInt32(0), numberBits.getInt32(4))\n}\n\n/** @internal */\nexport const hashArray = (values: ReadonlyArray<unknown>): number => {\n  let h = 0x811c9dc5 | 0\n  for (const value of values) {\n    h = combine(h, hash(value))\n  }\n  return h\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAa,cAA6B,OAAO,IAAI,mBAAmB;AAGxE,MAAa,aAA4B,OAAO,IAAI,kBAAkB;;AAUtE,MAAa,WAAW,MACtB,OAAO,MAAM,YAAY,MAAM,QAAQ,eAAe;;AAGxD,MAAa,UAAU,GAAY,MAAwB;CACzD,IAAI,MAAM,GACR,OAAO;CAET,IAAI,QAAQ,CAAC,KAAK,QAAQ,CAAC,GAAG;EAC5B,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GACpC,OAAO;EAET,OAAO,EAAE,YAAY,CAAC,CAAC;CACzB;CACA,OAAO;AACT;;AAGA,MAAa,QAAQ,MAAuB;CAC1C,QAAQ,OAAO,GAAf;EACE,KAAK,UACH,OAAO,WAAW,CAAC;EACrB,KAAK,UACH,OAAO,WAAW,CAAC;EACrB,KAAK,WACH,OAAO,IAAI,OAAO;EACpB,KAAK,aACH,OAAO;EACT,KAAK;GACH,IAAI,MAAM,MACR,OAAO;GAET,IAAI,QAAQ,CAAC,GACX,OAAO,EAAE,WAAW,CAAC;GAEvB,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;AAOA,MAAa,WAAW,GAAW,MAChC,IAAK,IAAI,cAAc,KAAK,MAAM,MAAM,KAAO;;;;;;AAOlD,MAAa,cAAc,MAAsB;CAC/C,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;EACjC,KAAK,EAAE,WAAW,CAAC;EACnB,IAAI,KAAK,KAAK,GAAG,QAAU;CAC7B;CACA,OAAO,IAAI;AACb;AAEA,MAAM,6BAAa,IAAI,yBAAS,IAAI,YAAY,CAAC,CAAC;;;;;;;AAQlD,MAAa,cAAc,MAAsB;CAC/C,WAAW,WAAW,GAAG,MAAM,IAAI,IAAI,CAAC;CACxC,OAAO,QAAQ,WAAW,SAAS,CAAC,GAAG,WAAW,SAAS,CAAC,CAAC;AAC/D"}

package/dist/shared/fontFaceRule-C7nYgH6X.d.mts

@@ -0,0 +1,294 @@
+import { t as Pipeable } from "./utils-BKm298I-.mjs";
+import { n as RenderOptions$1 } from "./declaration-1DlO_ltT.mjs";
+//#region src/fontFace/fontFaceRule.internal.d.ts
+declare const FontFaceRuleTypeId: unique symbol;
+type FontFaceRuleTypeId = typeof FontFaceRuleTypeId;
+declare const SourceTypeId: unique symbol;
+type SourceTypeId = typeof SourceTypeId;
+declare namespace fontFaceRule_d_exports {
+  export { Descriptors, Display, FontFaceRule, RenderOptions, Source, Style, UnicodeRange, Weight, equals, isFontFaceRule, isSource, local, make, render, url };
+}
+/**
+ * An `@font-face` rule: a font family, its sources, and the optional
+ * descriptors that scope and adjust the face.
+ *
+ * A declaration-block at-rule lives at the top level of a stylesheet —
+ * it is deliberately not a rule-block member, so it cannot nest. All
+ * fields are plain data: nothing in `@font-face` takes an expression.
+ *
+ * Construct via `make`.
+ *
+ * @since 0.1.0
+ */
+interface FontFaceRule extends Pipeable {
+  readonly [FontFaceRuleTypeId]: FontFaceRuleTypeId;
+  /**
+   * The `font-family` descriptor: the name the face binds to, quoted when
+   * rendered.
+   */
+  readonly family: string;
+  /**
+   * The `src` descriptor's sources, in authored order — the browser uses
+   * the first it supports.
+   */
+  readonly src: ReadonlyArray<Source>;
+  /**
+   * The `font-weight` descriptor: one weight or an ordered
+   * `[min, max]` range, in `[1, 1000]`.
+   */
+  readonly weight: Weight | undefined;
+  /**
+   * The `font-style` descriptor keyword.
+   */
+  readonly style: Style | undefined;
+  /**
+   * The `font-display` descriptor keyword.
+   */
+  readonly display: Display | undefined;
+  /**
+   * The `unicode-range` descriptor's ranges, canonically ordered (by
+   * start, then end) with exact duplicates dropped.
+   */
+  readonly unicodeRange: ReadonlyArray<UnicodeRange> | undefined;
+  /**
+   * The `ascent-override` metric, as a percentage number (`90` renders
+   * `90%`).
+   */
+  readonly ascentOverride: number | undefined;
+  /**
+   * The `descent-override` metric, as a percentage number.
+   */
+  readonly descentOverride: number | undefined;
+  /**
+   * The `line-gap-override` metric, as a percentage number.
+   */
+  readonly lineGapOverride: number | undefined;
+  /**
+   * The `size-adjust` metric, as a percentage number.
+   */
+  readonly sizeAdjust: number | undefined;
+}
+/**
+ * One entry of an `@font-face` `src` list: a downloadable `url(...)`
+ * (optionally with a `format(...)` hint) or a `local(...)` lookup.
+ *
+ * Construct via `url` and `local`.
+ *
+ * @since 0.1.0
+ */
+interface Source extends Pipeable {
+  readonly [SourceTypeId]: SourceTypeId;
+}
+/**
+ * A `font-weight` descriptor value: a single weight, or an ordered
+ * `[min, max]` range (`[100, 900]` renders `100 900`) for variable faces.
+ *
+ * @since 0.1.0
+ */
+type Weight = number | readonly [number, number];
+/**
+ * The `font-style` descriptor keywords. Oblique angle ranges are a later
+ * extension when a consumer needs them.
+ *
+ * @since 0.1.0
+ */
+type Style = 'normal' | 'italic' | 'oblique';
+/**
+ * The `font-display` descriptor keywords.
+ *
+ * @since 0.1.0
+ */
+type Display = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+/**
+ * One `unicode-range` descriptor entry: a single codepoint (`0x400`
+ * renders `U+400`) or an inclusive `[start, end]` range (`[0x400, 0x4ff]`
+ * renders `U+400-4FF`), each in `[0x0, 0x10FFFF]`.
+ *
+ * The wildcard spelling (`U+4??`) is range sugar and is not modeled.
+ *
+ * @since 0.2.0
+ */
+type UnicodeRange = number | readonly [start: number, end: number];
+/**
+ * The descriptors accepted by `make`.
+ *
+ * Metrics-adjusted fallback faces are the expected use: a face whose sole
+ * source is `local(...)`, carrying overrides computed from the primary
+ * face's metrics.
+ *
+ * @since 0.1.0
+ */
+interface Descriptors {
+  /**
+   * The `font-family` descriptor: the name the face binds to. Required.
+   */
+  readonly family: string;
+  /**
+   * The `src` descriptor's sources, tried in the order given — the
+   * browser uses the first it supports. Required and non-empty.
+   */
+  readonly src: ReadonlyArray<Source>;
+  /**
+   * The `font-weight` descriptor: one weight or an ordered `[min, max]`
+   * range, each in `[1, 1000]`.
+   */
+  readonly weight?: Weight;
+  /**
+   * The `font-style` descriptor keyword.
+   */
+  readonly style?: Style;
+  /**
+   * The `font-display` descriptor keyword.
+   */
+  readonly display?: Display;
+  /**
+   * The `unicode-range` descriptor: the codepoints the face applies to,
+   * as single codepoints and inclusive `[start, end]` ranges. Non-empty
+   * when given. The descriptor is a set union, so entries canonicalize —
+   * sorted by start then end, exact duplicates dropped — and
+   * construction order never matters.
+   */
+  readonly unicodeRange?: ReadonlyArray<UnicodeRange>;
+  /**
+   * The `ascent-override` metric, as a percentage number (`90` means
+   * `90%`).
+   */
+  readonly ascentOverride?: number;
+  /**
+   * The `descent-override` metric, as a percentage number.
+   */
+  readonly descentOverride?: number;
+  /**
+   * The `line-gap-override` metric, as a percentage number.
+   */
+  readonly lineGapOverride?: number;
+  /**
+   * The `size-adjust` metric, as a percentage number.
+   */
+  readonly sizeAdjust?: number;
+}
+/**
+ * Options for `render`, in the render-options family rooted at
+ * `MediaQuery.RenderOptions` (via `Declaration.RenderOptions`). This
+ * renderer consumes `indent` and the inherited `precision` (for the
+ * weight and metric-override numbers); `mediaSyntax` is accepted and
+ * ignored, so one options object composes across the library.
+ *
+ * @since 0.1.0
+ */
+interface RenderOptions extends RenderOptions$1 {
+  /**
+   * The indentation unit for the block's declarations. Defaults to a tab.
+   */
+  readonly indent?: string;
+}
+/**
+ * Checks if a value is a `FontFaceRule`.
+ *
+ * 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 `FontFaceRule`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isFontFaceRule: (u: unknown) => u is FontFaceRule;
+/**
+ * Checks if a value is a font `Source`.
+ *
+ * True only for values built by `url` and `local`, which carry the brand.
+ *
+ * @param u - The value to check.
+ * @returns `true` if the value is a `Source`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isSource: (u: unknown) => u is Source;
+/**
+ * Creates a downloadable font source, rendered `url('href')` — with a
+ * `format('...')` hint appended when `format` is given.
+ *
+ * @param href - The URL the face loads from. Must be non-empty; rendered single-quoted with embedded quotes and backslashes escaped.
+ * @param format - The optional format hint (`woff2`, `woff`, ...). Must be non-empty when given.
+ * @returns A `Source` for `Descriptors.src`.
+ * @throws `Error` when `href` is empty, or `format` is given but empty.
+ * @since 0.1.0
+ */
+declare const url: (href: string, format?: string) => Source;
+/**
+ * Creates a local font lookup, rendered `local('name')` — the expected
+ * sole source of a metrics-adjusted fallback face.
+ *
+ * @param name - The locally installed family name. Must be non-empty; rendered single-quoted with embedded quotes and backslashes escaped.
+ * @returns A `Source` for `Descriptors.src`.
+ * @throws `Error` when `name` is empty.
+ * @since 0.1.0
+ */
+declare const local: (name: string) => Source;
+/**
+ * Creates an `@font-face` rule.
+ *
+ * @param descriptors - The face's descriptors; `family` and `src` are required.
+ * @returns A `FontFaceRule`.
+ * @throws `Error` when `family` is empty, `src` is empty, a weight is outside `[1, 1000]` or a range is out of order, a unicode-range entry is empty, out of order, or outside `[0x0, 0x10FFFF]`, or a metric override is negative or non-finite.
+ * @example
+ * ```ts
+ * FontFaceRule.make({
+ *   family: 'Inter',
+ *   weight: [100, 900],
+ *   style: 'normal',
+ *   display: 'swap',
+ *   src: [FontFaceRule.url('/fonts/inter-variable.woff2', 'woff2')],
+ * })
+ * ```
+ * @since 0.1.0
+ */
+declare const make: (descriptors: Descriptors) => FontFaceRule;
+/**
+ * Renders the rule as a complete `@font-face { ... }` block.
+ *
+ * Descriptors render in a fixed order — `font-family`, `font-weight`,
+ * `font-style`, `font-display`, `src`, `unicode-range`, then the metric
+ * overrides — one per line. A single-source `src` stays inline; multiple
+ * sources render one per line at double indent, comma-separated.
+ * Unicode ranges render uppercase-hex (`U+400, U+500-5FF`), in canonical
+ * order. Numbers format at the `precision` context (default
+ * `Precision.decimals(5)`); the metric descriptors append `%`.
+ *
+ * @param rule - The rule to render.
+ * @param options - Optional indentation unit and precision context.
+ * @returns Deterministic CSS text.
+ * @example
+ * ```ts
+ * FontFaceRule.render(
+ *   FontFaceRule.make({ family: 'Inter', src: [FontFaceRule.url('/inter.woff2', 'woff2')] }),
+ * )
+ * // "@font-face {\n\tfont-family: 'Inter';\n\tsrc: url('/inter.woff2') format('woff2');\n}"
+ * ```
+ * @since 0.1.0
+ */
+declare const render: (rule: FontFaceRule, options?: RenderOptions) => string;
+declare const equals: {
+  /**
+   * Returns a function that checks structural equality against `that`.
+   *
+   * @param that - The rule to compare against.
+   * @returns A function testing its argument for structural equality with `that`.
+   * @since 0.1.0
+   */
+  (that: FontFaceRule): (self: FontFaceRule) => boolean;
+  /**
+   * Structural equality over descriptors. `src` order participates (it is
+   * fallback order); `unicode-range` order does not (entries canonicalize
+   * at construction); a single weight or codepoint never equals a range,
+   * even a degenerate one.
+   *
+   * @param self - The first rule.
+   * @param that - The second rule.
+   * @returns `true` if the rules are structurally equal.
+   * @since 0.1.0
+   */
+  (self: FontFaceRule, that: FontFaceRule): boolean;
+};
+//#endregion
+export { fontFaceRule_d_exports as n, FontFaceRule as t };
+//# sourceMappingURL=fontFaceRule-C7nYgH6X.d.mts.map