xantiagoma 0.2.1 → 0.3.0

package/README.md

@@ -26,23 +26,31 @@ Release process notes live in [docs/RELEASING.md](./docs/RELEASING.md).
 
 ## Entry Points
 
-| Import                          | Description                            | Dependencies                     |
-| ------------------------------- | -------------------------------------- | -------------------------------- |
-| `xantiagoma`                    | Core utilities (isomorphic, zero deps) | none                             |
-| `xantiagoma/pagination`         | Pagination + keyset helpers            | none                             |
-| `xantiagoma/pagination/drizzle` | Drizzle adapter for pagination keysets | `drizzle-orm`                    |
-| `xantiagoma/pagination/kysely`  | Kysely adapter for pagination keysets  | `kysely`                         |
-| `xantiagoma/pagination/knex`    | Knex adapter for pagination keysets    | none                             |
-| `xantiagoma/pagination/mongo`   | Mongo/Mongoose adapter for keysets     | none                             |
-| `xantiagoma/pagination/prisma`  | Prisma adapter for pagination keysets  | none                             |
-| `xantiagoma/web`                | Browser/FormData utilities             | none                             |
-| `xantiagoma/ulid`               | Prefixed ULID generation + helpers     | `ulid`                           |
-| `xantiagoma/temporal`           | Date/time/duration with Temporal API   | `temporal-polyfill`, `itty-time` |
-| `xantiagoma/dataloader`         | DataLoader factory                     | `dataloader`                     |
-| `xantiagoma/unstorage`          | Cache helpers with unstorage           | `unstorage`, `ohash`             |
-| `xantiagoma/valibot`            | TimeZone validation schema             | `valibot`                        |
-| `xantiagoma/sonner`             | Toast streaming for iterables          | `sonner`, `react`                |
-| `xantiagoma/react`              | React hooks + components               | `react`, `@tanstack/react-query` |
+| Import                          | Description                             | Dependencies                         |
+| ------------------------------- | --------------------------------------- | ------------------------------------ |
+| `xantiagoma`                    | Core utilities (isomorphic, zero deps)  | none                                 |
+| `xantiagoma/interval`           | Generic `Interval<T>` (Guava Range)     | none                                 |
+| `xantiagoma/dinero`             | Money intervals (`Interval` of money)   | `dinero.js`                          |
+| `xantiagoma/decimal`            | Exact-decimal intervals (decimal.js)    | `decimal.js`                         |
+| `xantiagoma/big`                | Exact-decimal intervals (big.js)        | `big.js`                             |
+| `xantiagoma/bignumber`          | Exact-decimal intervals (bignumber.js)  | `bignumber.js`                       |
+| `xantiagoma/fraction`           | Exact-rational intervals (fraction.js)  | `fraction.js`                        |
+| `xantiagoma/semver`             | Semantic-version range intervals        | `semver`                             |
+| `xantiagoma/ip`                 | IPv4/IPv6 address & CIDR intervals      | `ipaddr.js`                          |
+| `xantiagoma/pagination`         | Pagination + keyset helpers             | none                                 |
+| `xantiagoma/pagination/drizzle` | Drizzle adapter for pagination keysets  | `drizzle-orm`                        |
+| `xantiagoma/pagination/kysely`  | Kysely adapter for pagination keysets   | `kysely`                             |
+| `xantiagoma/pagination/knex`    | Knex adapter for pagination keysets     | none                                 |
+| `xantiagoma/pagination/mongo`   | Mongo/Mongoose adapter for keysets      | none                                 |
+| `xantiagoma/pagination/prisma`  | Prisma adapter for pagination keysets   | none                                 |
+| `xantiagoma/web`                | Browser/FormData utilities              | none                                 |
+| `xantiagoma/ulid`               | Prefixed ULID generation + helpers      | `ulid`                               |
+| `xantiagoma/temporal`           | Date/time/duration + Temporal intervals | `@js-temporal/polyfill`, `itty-time` |
+| `xantiagoma/dataloader`         | DataLoader factory                      | `dataloader`                         |
+| `xantiagoma/unstorage`          | Cache helpers with unstorage            | `unstorage`, `ohash`                 |
+| `xantiagoma/valibot`            | TimeZone validation schema              | `valibot`                            |
+| `xantiagoma/sonner`             | Toast streaming for iterables           | `sonner`, `react`                    |
+| `xantiagoma/react`              | React hooks + components                | `react`, `@tanstack/react-query`     |
 
 Sub-entry dependencies are **optional peer deps** — only install what you use.
 
@@ -114,6 +122,129 @@ Sub-entry dependencies are **optional peer deps** — only install what you use.
 | `resolveStreamSource`                       | Resolve `StreamSource<T>`               | [src](./src/stream-source.ts)         | [tests](./test/stream-source.test.ts)         |
 | `secondsToMs` / `minutesToMs` / `hoursToMs` | Time unit converters                    | [src](./src/time-convert.ts)          | [tests](./test/time-convert.test.ts)          |
 
+## Interval Utilities (`xantiagoma/interval`)
+
+A generic, immutable `Interval<T>` over any ordered type — modeled on Guava's
+`Range` + `DiscreteDomain`. The engine knows nothing about `T` except through an
+injected `IntervalDomain<T>` (compare, optional successor/measure/format/parse,
+and the domain's `±∞` values). Zero dependencies. **Full guide:
+[docs/INTERVAL.md](./docs/INTERVAL.md).**
+
+```ts
+import { NumberInterval, IntegerInterval } from "xantiagoma/interval";
+
+const r = new NumberInterval({ start: 0, startClose: true, end: 10, endClose: false }); // [0,10)
+r.contains(5); // true
+r.union(NumberInterval.closedOpen(10, 20))?.toString(); // "[0,20)"
+NumberInterval.parse("(-Infinity,5]").contains(-3); // true
+
+// discrete domains merge epsilon-adjacent ranges:
+IntegerInterval.closed(1, 5).union(IntegerInterval.closed(6, 10))?.toString(); // "[1,10]"
+```
+
+| Export                                                                                      | Description                                             | Source                           | Tests                                    |
+| ------------------------------------------------------------------------------------------- | ------------------------------------------------------- | -------------------------------- | ---------------------------------------- |
+| `Interval`                                                                                  | Immutable interval engine (set algebra over a domain)   | [src](./src/interval.ts)         | [tests](./test/interval.test.ts)         |
+| `defineIntervalType`                                                                        | Bind a domain → `new`-able interval class + statics     | [src](./src/interval.ts)         | [tests](./test/interval.test.ts)         |
+| `parseInterval` / `mergeIntervals`                                                          | Parse `[a,b)` strings; merge a bag into disjoint pieces | [src](./src/interval.ts)         | [tests](./test/interval.test.ts)         |
+| `numberDomain` / `integerDomain` / `bigIntDomain` / `dateDomain` / `stringDomain`           | Built-in `IntervalDomain<T>`s (zero-dep)                | [src](./src/interval-domains.ts) | [tests](./test/interval-domains.test.ts) |
+| `NumberInterval` / `IntegerInterval` / `BigIntInterval` / `DateInterval` / `StringInterval` | Ready-to-use classes (incl. lexicographic strings)      | [src](./src/interval-domains.ts) | [tests](./test/interval-domains.test.ts) |
+| `createOrdinalInterval(labels)`                                                             | Discrete intervals over an ordered label list (enums)   | [src](./src/interval-domains.ts) | [tests](./test/interval-domains.test.ts) |
+
+**Temporal intervals** (`xantiagoma/temporal`, peer `@js-temporal/polyfill`) — the
+same engine bound to the TC39 `Temporal` types:
+`InstantInterval`, `ZonedDateTimeInterval`, `PlainDateInterval` (discrete, ε 1 day),
+`PlainDateTimeInterval`, `PlainTimeInterval` (+ the matching `instantDomain` … exports).
+Ordering/membership are nanosecond-exact; `length()`/`middle()` are millisecond-granular
+(day-granular for `PlainDate`) — see [docs/INTERVAL.md](./docs/INTERVAL.md#temporal-intervals).
+
+```ts
+import { PlainTimeInterval, InstantInterval } from "xantiagoma/temporal";
+import { Temporal } from "@js-temporal/polyfill";
+
+const shift = PlainTimeInterval.closedOpen(
+  Temporal.PlainTime.from("09:00"),
+  Temporal.PlainTime.from("17:00"),
+);
+shift.contains(Temporal.PlainTime.from("12:30")); // true
+shift.length(); // 28_800_000 (ms = 8h)
+```
+
+**Money intervals** (`xantiagoma/dinero`, peer `dinero.js`) — the engine bound to
+dinero.js v2 values, **discrete** with the epsilon being one minor unit (1 cent for
+USD, 1 yen for JPY) so adjacent ranges merge and `length()` counts amounts. Build a
+class per currency with `createDineroInterval(currency)` — see
+[docs/INTERVAL.md](./docs/INTERVAL.md#money-intervals).
+
+```ts
+import { createDineroInterval } from "xantiagoma/dinero";
+import { dinero, USD } from "dinero.js";
+
+const UsdInterval = createDineroInterval(USD);
+const tier = UsdInterval.closed(
+  dinero({ amount: 5_000, currency: USD }),
+  dinero({ amount: 10_000, currency: USD }),
+);
+tier.contains(dinero({ amount: 7_500, currency: USD })); // true ($75 ∈ [$50, $100])
+tier.toString(); // "[5000,10000]"  (minor units)
+```
+
+**Decimal intervals** (`xantiagoma/decimal`, peer `decimal.js`) — an exact, continuous
+alternative to `NumberInterval` when IEEE-754 float fuzz is unacceptable. Ordering,
+membership, and the string form are exact arbitrary-precision; see
+[docs/INTERVAL.md](./docs/INTERVAL.md#decimal-intervals).
+
+```ts
+import { DecimalInterval } from "xantiagoma/decimal";
+import Decimal from "decimal.js";
+
+DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3")).length(); // 0.2 (not 0.19999999999999998)
+DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3")).toString(); // "[0.1,0.3]"
+```
+
+Same exact-decimal model, different backing library (pick the one you already use):
+**`xantiagoma/big`** (`BigInterval`, peer `big.js` — smaller) and **`xantiagoma/bignumber`**
+(`BigNumberInterval`, peer `bignumber.js`).
+
+**Fraction intervals** (`xantiagoma/fraction`, peer `fraction.js`) — exact **rationals**:
+`1/3` is lossless (never rounds, even where decimals can't) and renders as `"1/3"`. See
+[docs/INTERVAL.md](./docs/INTERVAL.md#fraction-intervals).
+
+```ts
+import { FractionInterval } from "xantiagoma/fraction";
+import Fraction from "fraction.js";
+
+const third = (n: number) => new Fraction(n, 3);
+FractionInterval.closed(third(1), third(2)).toString(); // "[1/3,2/3]"
+FractionInterval.closed(third(1), third(2)).contains(new Fraction(1, 2)); // true
+```
+
+**Semver intervals** (`xantiagoma/semver`, peer `semver`) — a version range IS an interval
+(`[">=1.2.0","<2.0.0")`). Exact precedence ordering; see
+[docs/INTERVAL.md](./docs/INTERVAL.md#semver-intervals).
+
+```ts
+import { SemverInterval } from "xantiagoma/semver";
+
+const compatible = SemverInterval.closedOpen("1.2.0", "2.0.0");
+compatible.contains("1.5.3"); // true
+compatible.contains("2.0.0"); // false
+```
+
+**IP intervals** (`xantiagoma/ip`, peer `ipaddr.js`) — IPv4/IPv6 ranges, discrete (ε = one
+address), CIDR-aware. See [docs/INTERVAL.md](./docs/INTERVAL.md#ip-intervals).
+
+```ts
+import { Ipv4Interval } from "xantiagoma/ip";
+
+const lan = Ipv4Interval.cidr("192.168.0.0/16");
+lan.contains(Ipv4Interval.ip("192.168.1.50")); // true
+lan.length(); // 65536
+```
+
+Strings and ordered enums need no extra dependency — `StringInterval` (lexicographic) and
+`createOrdinalInterval([...])` (ordered labels) ship in `xantiagoma/interval`.
+
 ## Pagination Utilities (`xantiagoma/pagination`)
 
 Source-agnostic pagination: import from `xantiagoma/pagination`, provide fetchers for your data source (SQL, Drizzle, Prisma, Mongoose, HTTP...), and the paginator handles input styles (`page`/`pageSize`, `limit`/`offset`, cursor), `hasNextPage` lookahead, backward (scroll-up) pagination, and a uniform result envelope. **Full guide: [docs/PAGINATION.md](./docs/PAGINATION.md)** — backend recipes for SQL drivers, ORMs/query builders, Mongo, Firestore, DynamoDB, Redis sorted sets, Elasticsearch/OpenSearch, analytics warehouses, HTTP APIs, REST/GraphQL endpoints, cursor codecs, and frontend integration.
@@ -230,6 +361,13 @@ These are libraries we use and recommend. They're not re-exported — install th
 | [portakal](https://www.npmjs.com/package/portakal)                         | Printer / ESC/POS                   |
 | [hucre](https://www.npmjs.com/package/hucre)                               | Spreadsheet utilities               |
 | [@gobrand/tiempo](https://www.npmjs.com/package/@gobrand/tiempo)           | Time formatting / parsing           |
+| [dinero.js](https://dinerojs.com/)                                         | Immutable, type-safe money handling |
+| [decimal.js](https://github.com/MikeMcl/decimal.js)                        | Arbitrary-precision decimals        |
+| [big.js](https://github.com/MikeMcl/big.js)                                | Minimalist arbitrary-precision dec. |
+| [bignumber.js](https://github.com/MikeMcl/bignumber.js)                    | Arbitrary-precision decimals/bases  |
+| [fraction.js](https://github.com/rawify/Fraction.js)                       | Exact rational numbers              |
+| [semver](https://github.com/npm/node-semver)                               | Semantic version parsing/compare    |
+| [ipaddr.js](https://github.com/whitequark/ipaddr.js)                       | IPv4/IPv6 address parsing           |
 | [tactus](https://www.npmjs.com/package/tactus)                             | Haptic feedback for web             |
 | [liveline](https://www.npmjs.com/package/liveline)                         | Animated line charts (React)        |
 | [react-lzy-img](https://www.npmjs.com/package/react-lzy-img)               | Lazy loading images (React)         |

package/dist/entry-big.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-CKQMccvm.cjs");
+const require_interval = require("./interval-BsZKdewu.cjs");
+let big_js = require("big.js");
+big_js = require_chunk.__toESM(big_js, 1);
+//#region src/interval-big.ts
+/**
+* Exact-decimal intervals backed by [big.js](https://github.com/MikeMcl/big.js) —
+* a minimalist arbitrary-precision decimal. Same model as `xantiagoma/decimal`
+* (decimal.js) but a much smaller dependency; pick whichever big-number library
+* you already use. CONTINUOUS (decimals are dense). big.js is a **peer dependency**.
+*
+* Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/
+* `middle()` round-trip through a JS `number` (the engine's `measure` type).
+* big.js values are always finite — it throws on `NaN`/`Infinity` construction —
+* so there is no `isValid` guard.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */
+const bigDomain = {
+	name: "big",
+	compare: (a, b) => a.cmp(b),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new big_js.default(text)
+};
+/**
+* Interval over big.js `Big` values — exact, continuous.
+*
+*   import { BigInterval } from "xantiagoma/big";
+*   import Big from "big.js";
+*
+*   BigInterval.closed(new Big("0.1"), new Big("0.3")).length(); // 0.2 (exact)
+*/
+const BigInterval = require_interval.defineIntervalType(bigDomain);
+//#endregion
+exports.BigInterval = BigInterval;
+exports.bigDomain = bigDomain;
+
+//# sourceMappingURL=entry-big.cjs.map

package/dist/entry-big.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-big.cjs","names":["Big","defineIntervalType"],"sources":["../src/interval-big.ts"],"sourcesContent":["/**\n * Exact-decimal intervals backed by [big.js](https://github.com/MikeMcl/big.js) —\n * a minimalist arbitrary-precision decimal. Same model as `xantiagoma/decimal`\n * (decimal.js) but a much smaller dependency; pick whichever big-number library\n * you already use. CONTINUOUS (decimals are dense). big.js is a **peer dependency**.\n *\n * Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/\n * `middle()` round-trip through a JS `number` (the engine's `measure` type).\n * big.js values are always finite — it throws on `NaN`/`Infinity` construction —\n * so there is no `isValid` guard.\n */\n\nimport Big from \"big.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\ntype BigValue = InstanceType<typeof Big>;\n\n/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */\nexport const bigDomain: IntervalDomain<BigValue> = {\n  name: \"big\",\n  compare: (a, b) => a.cmp(b),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new Big(text),\n};\n\n/**\n * Interval over big.js `Big` values — exact, continuous.\n *\n *   import { BigInterval } from \"xantiagoma/big\";\n *   import Big from \"big.js\";\n *\n *   BigInterval.closed(new Big(\"0.1\"), new Big(\"0.3\")).length(); // 0.2 (exact)\n */\nexport const BigInterval: BoundIntervalType<BigValue> = defineIntervalType(bigDomain);\n/** Instance type of {@link BigInterval}. */\nexport type BigInterval = InstanceType<typeof BigInterval>;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAa,YAAsC;CACjD,MAAM;CACN,UAAU,GAAG,MAAM,EAAE,IAAI,EAAE;CAC3B,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAIA,OAAAA,QAAI,KAAK;CAC/B;;;;;;;;;AAUD,MAAa,cAA2CC,iBAAAA,mBAAmB,UAAU"}

package/dist/entry-big.d.cts

@@ -0,0 +1,21 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-Cz4Twj1-.cjs";
+import Big from "big.js";
+
+//#region src/interval-big.d.ts
+type BigValue = InstanceType<typeof Big>;
+/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */
+declare const bigDomain: IntervalDomain<BigValue>;
+/**
+ * Interval over big.js `Big` values — exact, continuous.
+ *
+ *   import { BigInterval } from "xantiagoma/big";
+ *   import Big from "big.js";
+ *
+ *   BigInterval.closed(new Big("0.1"), new Big("0.3")).length(); // 0.2 (exact)
+ */
+declare const BigInterval: BoundIntervalType<BigValue>;
+/** Instance type of {@link BigInterval}. */
+type BigInterval = InstanceType<typeof BigInterval>;
+//#endregion
+export { BigInterval, bigDomain };
+//# sourceMappingURL=entry-big.d.cts.map

package/dist/entry-big.d.mts

@@ -0,0 +1,21 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-D1wAtNyH.mjs";
+import Big from "big.js";
+
+//#region src/interval-big.d.ts
+type BigValue = InstanceType<typeof Big>;
+/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */
+declare const bigDomain: IntervalDomain<BigValue>;
+/**
+ * Interval over big.js `Big` values — exact, continuous.
+ *
+ *   import { BigInterval } from "xantiagoma/big";
+ *   import Big from "big.js";
+ *
+ *   BigInterval.closed(new Big("0.1"), new Big("0.3")).length(); // 0.2 (exact)
+ */
+declare const BigInterval: BoundIntervalType<BigValue>;
+/** Instance type of {@link BigInterval}. */
+type BigInterval = InstanceType<typeof BigInterval>;
+//#endregion
+export { BigInterval, bigDomain };
+//# sourceMappingURL=entry-big.d.mts.map

package/dist/entry-big.mjs

@@ -0,0 +1,36 @@
+import { n as defineIntervalType } from "./interval-C_s8UAce.mjs";
+import Big from "big.js";
+//#region src/interval-big.ts
+/**
+* Exact-decimal intervals backed by [big.js](https://github.com/MikeMcl/big.js) —
+* a minimalist arbitrary-precision decimal. Same model as `xantiagoma/decimal`
+* (decimal.js) but a much smaller dependency; pick whichever big-number library
+* you already use. CONTINUOUS (decimals are dense). big.js is a **peer dependency**.
+*
+* Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/
+* `middle()` round-trip through a JS `number` (the engine's `measure` type).
+* big.js values are always finite — it throws on `NaN`/`Infinity` construction —
+* so there is no `isValid` guard.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */
+const bigDomain = {
+	name: "big",
+	compare: (a, b) => a.cmp(b),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new Big(text)
+};
+/**
+* Interval over big.js `Big` values — exact, continuous.
+*
+*   import { BigInterval } from "xantiagoma/big";
+*   import Big from "big.js";
+*
+*   BigInterval.closed(new Big("0.1"), new Big("0.3")).length(); // 0.2 (exact)
+*/
+const BigInterval = defineIntervalType(bigDomain);
+//#endregion
+export { BigInterval, bigDomain };
+
+//# sourceMappingURL=entry-big.mjs.map

package/dist/entry-big.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-big.mjs","names":[],"sources":["../src/interval-big.ts"],"sourcesContent":["/**\n * Exact-decimal intervals backed by [big.js](https://github.com/MikeMcl/big.js) —\n * a minimalist arbitrary-precision decimal. Same model as `xantiagoma/decimal`\n * (decimal.js) but a much smaller dependency; pick whichever big-number library\n * you already use. CONTINUOUS (decimals are dense). big.js is a **peer dependency**.\n *\n * Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/\n * `middle()` round-trip through a JS `number` (the engine's `measure` type).\n * big.js values are always finite — it throws on `NaN`/`Infinity` construction —\n * so there is no `isValid` guard.\n */\n\nimport Big from \"big.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\ntype BigValue = InstanceType<typeof Big>;\n\n/** Exact-decimal {@link IntervalDomain} backed by big.js. Continuous. */\nexport const bigDomain: IntervalDomain<BigValue> = {\n  name: \"big\",\n  compare: (a, b) => a.cmp(b),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new Big(text),\n};\n\n/**\n * Interval over big.js `Big` values — exact, continuous.\n *\n *   import { BigInterval } from \"xantiagoma/big\";\n *   import Big from \"big.js\";\n *\n *   BigInterval.closed(new Big(\"0.1\"), new Big(\"0.3\")).length(); // 0.2 (exact)\n */\nexport const BigInterval: BoundIntervalType<BigValue> = defineIntervalType(bigDomain);\n/** Instance type of {@link BigInterval}. */\nexport type BigInterval = InstanceType<typeof BigInterval>;\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,MAAa,YAAsC;CACjD,MAAM;CACN,UAAU,GAAG,MAAM,EAAE,IAAI,EAAE;CAC3B,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAI,IAAI,KAAK;CAC/B;;;;;;;;;AAUD,MAAa,cAA2C,mBAAmB,UAAU"}

package/dist/entry-bignumber.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-CKQMccvm.cjs");
+const require_interval = require("./interval-BsZKdewu.cjs");
+let bignumber_js = require("bignumber.js");
+//#region src/interval-bignumber.ts
+/**
+* Exact-decimal intervals backed by [bignumber.js](https://github.com/MikeMcl/bignumber.js)
+* — arbitrary-precision decimals with base conversion (popular in finance/crypto).
+* Same model as `xantiagoma/decimal`; pick the big-number library you already use.
+* CONTINUOUS (decimals are dense). bignumber.js is a **peer dependency**.
+*
+* Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/
+* `middle()` round-trip through a JS `number`. Members must be finite — `NaN`/
+* `±Infinity` are rejected by `contains`.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */
+const bigNumberDomain = {
+	name: "bignumber",
+	compare: (a, b) => a.comparedTo(b) ?? 0,
+	isValid: (value) => value.isFinite(),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new bignumber_js.BigNumber(text)
+};
+/**
+* Interval over bignumber.js `BigNumber` values — exact, continuous.
+*
+*   import { BigNumberInterval } from "xantiagoma/bignumber";
+*   import { BigNumber } from "bignumber.js";
+*
+*   BigNumberInterval.closed(new BigNumber("0.1"), new BigNumber("0.3")).length(); // 0.2 (exact)
+*/
+const BigNumberInterval = require_interval.defineIntervalType(bigNumberDomain);
+//#endregion
+exports.BigNumberInterval = BigNumberInterval;
+exports.bigNumberDomain = bigNumberDomain;
+
+//# sourceMappingURL=entry-bignumber.cjs.map

package/dist/entry-bignumber.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-bignumber.cjs","names":["BigNumber","defineIntervalType"],"sources":["../src/interval-bignumber.ts"],"sourcesContent":["/**\n * Exact-decimal intervals backed by [bignumber.js](https://github.com/MikeMcl/bignumber.js)\n * — arbitrary-precision decimals with base conversion (popular in finance/crypto).\n * Same model as `xantiagoma/decimal`; pick the big-number library you already use.\n * CONTINUOUS (decimals are dense). bignumber.js is a **peer dependency**.\n *\n * Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/\n * `middle()` round-trip through a JS `number`. Members must be finite — `NaN`/\n * `±Infinity` are rejected by `contains`.\n */\n\nimport { BigNumber } from \"bignumber.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\n/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */\nexport const bigNumberDomain: IntervalDomain<BigNumber> = {\n  name: \"bignumber\",\n  // comparedTo is null only when a NaN is involved; finite members never hit that.\n  compare: (a, b) => a.comparedTo(b) ?? 0,\n  isValid: (value) => value.isFinite(),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new BigNumber(text),\n};\n\n/**\n * Interval over bignumber.js `BigNumber` values — exact, continuous.\n *\n *   import { BigNumberInterval } from \"xantiagoma/bignumber\";\n *   import { BigNumber } from \"bignumber.js\";\n *\n *   BigNumberInterval.closed(new BigNumber(\"0.1\"), new BigNumber(\"0.3\")).length(); // 0.2 (exact)\n */\nexport const BigNumberInterval: BoundIntervalType<BigNumber> = defineIntervalType(bigNumberDomain);\n/** Instance type of {@link BigNumberInterval}. */\nexport type BigNumberInterval = InstanceType<typeof BigNumberInterval>;\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,kBAA6C;CACxD,MAAM;CAEN,UAAU,GAAG,MAAM,EAAE,WAAW,EAAE,IAAI;CACtC,UAAU,UAAU,MAAM,UAAU;CACpC,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAIA,aAAAA,UAAU,KAAK;CACrC;;;;;;;;;AAUD,MAAa,oBAAkDC,iBAAAA,mBAAmB,gBAAgB"}

package/dist/entry-bignumber.d.cts

@@ -0,0 +1,20 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-Cz4Twj1-.cjs";
+import { BigNumber } from "bignumber.js";
+
+//#region src/interval-bignumber.d.ts
+/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */
+declare const bigNumberDomain: IntervalDomain<BigNumber>;
+/**
+ * Interval over bignumber.js `BigNumber` values — exact, continuous.
+ *
+ *   import { BigNumberInterval } from "xantiagoma/bignumber";
+ *   import { BigNumber } from "bignumber.js";
+ *
+ *   BigNumberInterval.closed(new BigNumber("0.1"), new BigNumber("0.3")).length(); // 0.2 (exact)
+ */
+declare const BigNumberInterval: BoundIntervalType<BigNumber>;
+/** Instance type of {@link BigNumberInterval}. */
+type BigNumberInterval = InstanceType<typeof BigNumberInterval>;
+//#endregion
+export { BigNumberInterval, bigNumberDomain };
+//# sourceMappingURL=entry-bignumber.d.cts.map

package/dist/entry-bignumber.d.mts

@@ -0,0 +1,20 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-D1wAtNyH.mjs";
+import { BigNumber } from "bignumber.js";
+
+//#region src/interval-bignumber.d.ts
+/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */
+declare const bigNumberDomain: IntervalDomain<BigNumber>;
+/**
+ * Interval over bignumber.js `BigNumber` values — exact, continuous.
+ *
+ *   import { BigNumberInterval } from "xantiagoma/bignumber";
+ *   import { BigNumber } from "bignumber.js";
+ *
+ *   BigNumberInterval.closed(new BigNumber("0.1"), new BigNumber("0.3")).length(); // 0.2 (exact)
+ */
+declare const BigNumberInterval: BoundIntervalType<BigNumber>;
+/** Instance type of {@link BigNumberInterval}. */
+type BigNumberInterval = InstanceType<typeof BigNumberInterval>;
+//#endregion
+export { BigNumberInterval, bigNumberDomain };
+//# sourceMappingURL=entry-bignumber.d.mts.map

package/dist/entry-bignumber.mjs

@@ -0,0 +1,36 @@
+import { n as defineIntervalType } from "./interval-C_s8UAce.mjs";
+import { BigNumber } from "bignumber.js";
+//#region src/interval-bignumber.ts
+/**
+* Exact-decimal intervals backed by [bignumber.js](https://github.com/MikeMcl/bignumber.js)
+* — arbitrary-precision decimals with base conversion (popular in finance/crypto).
+* Same model as `xantiagoma/decimal`; pick the big-number library you already use.
+* CONTINUOUS (decimals are dense). bignumber.js is a **peer dependency**.
+*
+* Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/
+* `middle()` round-trip through a JS `number`. Members must be finite — `NaN`/
+* `±Infinity` are rejected by `contains`.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */
+const bigNumberDomain = {
+	name: "bignumber",
+	compare: (a, b) => a.comparedTo(b) ?? 0,
+	isValid: (value) => value.isFinite(),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new BigNumber(text)
+};
+/**
+* Interval over bignumber.js `BigNumber` values — exact, continuous.
+*
+*   import { BigNumberInterval } from "xantiagoma/bignumber";
+*   import { BigNumber } from "bignumber.js";
+*
+*   BigNumberInterval.closed(new BigNumber("0.1"), new BigNumber("0.3")).length(); // 0.2 (exact)
+*/
+const BigNumberInterval = defineIntervalType(bigNumberDomain);
+//#endregion
+export { BigNumberInterval, bigNumberDomain };
+
+//# sourceMappingURL=entry-bignumber.mjs.map

package/dist/entry-bignumber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-bignumber.mjs","names":[],"sources":["../src/interval-bignumber.ts"],"sourcesContent":["/**\n * Exact-decimal intervals backed by [bignumber.js](https://github.com/MikeMcl/bignumber.js)\n * — arbitrary-precision decimals with base conversion (popular in finance/crypto).\n * Same model as `xantiagoma/decimal`; pick the big-number library you already use.\n * CONTINUOUS (decimals are dense). bignumber.js is a **peer dependency**.\n *\n * Ordering, membership, and `toString`/`parse` are exact; `measure`/`length()`/\n * `middle()` round-trip through a JS `number`. Members must be finite — `NaN`/\n * `±Infinity` are rejected by `contains`.\n */\n\nimport { BigNumber } from \"bignumber.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\n/** Exact-decimal {@link IntervalDomain} backed by bignumber.js. Continuous; finite-only. */\nexport const bigNumberDomain: IntervalDomain<BigNumber> = {\n  name: \"bignumber\",\n  // comparedTo is null only when a NaN is involved; finite members never hit that.\n  compare: (a, b) => a.comparedTo(b) ?? 0,\n  isValid: (value) => value.isFinite(),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new BigNumber(text),\n};\n\n/**\n * Interval over bignumber.js `BigNumber` values — exact, continuous.\n *\n *   import { BigNumberInterval } from \"xantiagoma/bignumber\";\n *   import { BigNumber } from \"bignumber.js\";\n *\n *   BigNumberInterval.closed(new BigNumber(\"0.1\"), new BigNumber(\"0.3\")).length(); // 0.2 (exact)\n */\nexport const BigNumberInterval: BoundIntervalType<BigNumber> = defineIntervalType(bigNumberDomain);\n/** Instance type of {@link BigNumberInterval}. */\nexport type BigNumberInterval = InstanceType<typeof BigNumberInterval>;\n"],"mappings":";;;;;;;;;;;;;;AAgBA,MAAa,kBAA6C;CACxD,MAAM;CAEN,UAAU,GAAG,MAAM,EAAE,WAAW,EAAE,IAAI;CACtC,UAAU,UAAU,MAAM,UAAU;CACpC,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAI,UAAU,KAAK;CACrC;;;;;;;;;AAUD,MAAa,oBAAkD,mBAAmB,gBAAgB"}

package/dist/entry-decimal.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-CKQMccvm.cjs");
+const require_interval = require("./interval-BsZKdewu.cjs");
+let decimal_js = require("decimal.js");
+decimal_js = require_chunk.__toESM(decimal_js, 1);
+//#region src/interval-decimal.ts
+/**
+* Arbitrary-precision decimal intervals — the generic `Interval<T>` engine bound
+* to [decimal.js](https://github.com/MikeMcl/decimal.js) `Decimal` values. Use
+* this instead of `NumberInterval` when you need exact decimals and the IEEE-754
+* float fuzz of `number` is unacceptable (e.g. `[0.1,0.3].length()` is `0.2`, not
+* `0.19999999999999998`, and `toString()` is `"[0.1,0.3]"`).
+*
+* CONTINUOUS — decimals are dense, so there's no true successor (no `next`/`prev`).
+* Ordering, membership, set operations, and parse/format are EXACT (backed by
+* decimal.js). `measure`/`length()`/`middle()` round-trip through a JS `number`
+* (the engine's `measure` return type), so the *result* of a measure is a double —
+* but it's computed exactly first, so clean decimals stay clean. decimal.js is a
+* **peer dependency**.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */
+const decimalDomain = {
+	name: "decimal",
+	compare: (a, b) => a.cmp(b),
+	isValid: (value) => value.isFinite(),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new decimal_js.default(text)
+};
+/**
+* Interval over decimal.js `Decimal` values — exact, continuous.
+*
+*   import { DecimalInterval } from "xantiagoma/decimal";
+*   import Decimal from "decimal.js";
+*
+*   const r = DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3"));
+*   r.length();        // 0.2   (exact — no float fuzz)
+*   r.toString();      // "[0.1,0.3]"
+*   r.contains(new Decimal("0.2")); // true
+*/
+const DecimalInterval = require_interval.defineIntervalType(decimalDomain);
+//#endregion
+exports.DecimalInterval = DecimalInterval;
+exports.decimalDomain = decimalDomain;
+
+//# sourceMappingURL=entry-decimal.cjs.map

package/dist/entry-decimal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-decimal.cjs","names":["Decimal","defineIntervalType"],"sources":["../src/interval-decimal.ts"],"sourcesContent":["/**\n * Arbitrary-precision decimal intervals — the generic `Interval<T>` engine bound\n * to [decimal.js](https://github.com/MikeMcl/decimal.js) `Decimal` values. Use\n * this instead of `NumberInterval` when you need exact decimals and the IEEE-754\n * float fuzz of `number` is unacceptable (e.g. `[0.1,0.3].length()` is `0.2`, not\n * `0.19999999999999998`, and `toString()` is `\"[0.1,0.3]\"`).\n *\n * CONTINUOUS — decimals are dense, so there's no true successor (no `next`/`prev`).\n * Ordering, membership, set operations, and parse/format are EXACT (backed by\n * decimal.js). `measure`/`length()`/`middle()` round-trip through a JS `number`\n * (the engine's `measure` return type), so the *result* of a measure is a double —\n * but it's computed exactly first, so clean decimals stay clean. decimal.js is a\n * **peer dependency**.\n */\n\nimport Decimal from \"decimal.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\n/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */\nexport const decimalDomain: IntervalDomain<Decimal> = {\n  name: \"decimal\",\n  compare: (a, b) => a.cmp(b),\n  isValid: (value) => value.isFinite(),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new Decimal(text),\n};\n\n/**\n * Interval over decimal.js `Decimal` values — exact, continuous.\n *\n *   import { DecimalInterval } from \"xantiagoma/decimal\";\n *   import Decimal from \"decimal.js\";\n *\n *   const r = DecimalInterval.closed(new Decimal(\"0.1\"), new Decimal(\"0.3\"));\n *   r.length();        // 0.2   (exact — no float fuzz)\n *   r.toString();      // \"[0.1,0.3]\"\n *   r.contains(new Decimal(\"0.2\")); // true\n */\nexport const DecimalInterval: BoundIntervalType<Decimal> = defineIntervalType(decimalDomain);\n/** Instance type of {@link DecimalInterval}. */\nexport type DecimalInterval = InstanceType<typeof DecimalInterval>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,gBAAyC;CACpD,MAAM;CACN,UAAU,GAAG,MAAM,EAAE,IAAI,EAAE;CAC3B,UAAU,UAAU,MAAM,UAAU;CACpC,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAIA,WAAAA,QAAQ,KAAK;CACnC;;;;;;;;;;;;AAaD,MAAa,kBAA8CC,iBAAAA,mBAAmB,cAAc"}

package/dist/entry-decimal.d.cts

@@ -0,0 +1,23 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-Cz4Twj1-.cjs";
+import Decimal from "decimal.js";
+
+//#region src/interval-decimal.d.ts
+/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */
+declare const decimalDomain: IntervalDomain<Decimal>;
+/**
+ * Interval over decimal.js `Decimal` values — exact, continuous.
+ *
+ *   import { DecimalInterval } from "xantiagoma/decimal";
+ *   import Decimal from "decimal.js";
+ *
+ *   const r = DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3"));
+ *   r.length();        // 0.2   (exact — no float fuzz)
+ *   r.toString();      // "[0.1,0.3]"
+ *   r.contains(new Decimal("0.2")); // true
+ */
+declare const DecimalInterval: BoundIntervalType<Decimal>;
+/** Instance type of {@link DecimalInterval}. */
+type DecimalInterval = InstanceType<typeof DecimalInterval>;
+//#endregion
+export { DecimalInterval, decimalDomain };
+//# sourceMappingURL=entry-decimal.d.cts.map

package/dist/entry-decimal.d.mts

@@ -0,0 +1,23 @@
+import { i as IntervalDomain, n as BoundIntervalType } from "./interval-D1wAtNyH.mjs";
+import Decimal from "decimal.js";
+
+//#region src/interval-decimal.d.ts
+/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */
+declare const decimalDomain: IntervalDomain<Decimal>;
+/**
+ * Interval over decimal.js `Decimal` values — exact, continuous.
+ *
+ *   import { DecimalInterval } from "xantiagoma/decimal";
+ *   import Decimal from "decimal.js";
+ *
+ *   const r = DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3"));
+ *   r.length();        // 0.2   (exact — no float fuzz)
+ *   r.toString();      // "[0.1,0.3]"
+ *   r.contains(new Decimal("0.2")); // true
+ */
+declare const DecimalInterval: BoundIntervalType<Decimal>;
+/** Instance type of {@link DecimalInterval}. */
+type DecimalInterval = InstanceType<typeof DecimalInterval>;
+//#endregion
+export { DecimalInterval, decimalDomain };
+//# sourceMappingURL=entry-decimal.d.mts.map

package/dist/entry-decimal.mjs

@@ -0,0 +1,43 @@
+import { n as defineIntervalType } from "./interval-C_s8UAce.mjs";
+import Decimal from "decimal.js";
+//#region src/interval-decimal.ts
+/**
+* Arbitrary-precision decimal intervals — the generic `Interval<T>` engine bound
+* to [decimal.js](https://github.com/MikeMcl/decimal.js) `Decimal` values. Use
+* this instead of `NumberInterval` when you need exact decimals and the IEEE-754
+* float fuzz of `number` is unacceptable (e.g. `[0.1,0.3].length()` is `0.2`, not
+* `0.19999999999999998`, and `toString()` is `"[0.1,0.3]"`).
+*
+* CONTINUOUS — decimals are dense, so there's no true successor (no `next`/`prev`).
+* Ordering, membership, set operations, and parse/format are EXACT (backed by
+* decimal.js). `measure`/`length()`/`middle()` round-trip through a JS `number`
+* (the engine's `measure` return type), so the *result* of a measure is a double —
+* but it's computed exactly first, so clean decimals stay clean. decimal.js is a
+* **peer dependency**.
+*/
+/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */
+const decimalDomain = {
+	name: "decimal",
+	compare: (a, b) => a.cmp(b),
+	isValid: (value) => value.isFinite(),
+	measure: (lower, upper) => upper.minus(lower).toNumber(),
+	add: (value, delta) => value.plus(delta),
+	format: (value) => value.toString(),
+	parse: (text) => new Decimal(text)
+};
+/**
+* Interval over decimal.js `Decimal` values — exact, continuous.
+*
+*   import { DecimalInterval } from "xantiagoma/decimal";
+*   import Decimal from "decimal.js";
+*
+*   const r = DecimalInterval.closed(new Decimal("0.1"), new Decimal("0.3"));
+*   r.length();        // 0.2   (exact — no float fuzz)
+*   r.toString();      // "[0.1,0.3]"
+*   r.contains(new Decimal("0.2")); // true
+*/
+const DecimalInterval = defineIntervalType(decimalDomain);
+//#endregion
+export { DecimalInterval, decimalDomain };
+
+//# sourceMappingURL=entry-decimal.mjs.map

package/dist/entry-decimal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-decimal.mjs","names":[],"sources":["../src/interval-decimal.ts"],"sourcesContent":["/**\n * Arbitrary-precision decimal intervals — the generic `Interval<T>` engine bound\n * to [decimal.js](https://github.com/MikeMcl/decimal.js) `Decimal` values. Use\n * this instead of `NumberInterval` when you need exact decimals and the IEEE-754\n * float fuzz of `number` is unacceptable (e.g. `[0.1,0.3].length()` is `0.2`, not\n * `0.19999999999999998`, and `toString()` is `\"[0.1,0.3]\"`).\n *\n * CONTINUOUS — decimals are dense, so there's no true successor (no `next`/`prev`).\n * Ordering, membership, set operations, and parse/format are EXACT (backed by\n * decimal.js). `measure`/`length()`/`middle()` round-trip through a JS `number`\n * (the engine's `measure` return type), so the *result* of a measure is a double —\n * but it's computed exactly first, so clean decimals stay clean. decimal.js is a\n * **peer dependency**.\n */\n\nimport Decimal from \"decimal.js\";\n\nimport { type BoundIntervalType, defineIntervalType, type IntervalDomain } from \"./interval.ts\";\n\n/** Exact-decimal {@link IntervalDomain} backed by decimal.js. Continuous; finite-only. */\nexport const decimalDomain: IntervalDomain<Decimal> = {\n  name: \"decimal\",\n  compare: (a, b) => a.cmp(b),\n  isValid: (value) => value.isFinite(),\n  measure: (lower, upper) => upper.minus(lower).toNumber(),\n  add: (value, delta) => value.plus(delta),\n  format: (value) => value.toString(),\n  parse: (text) => new Decimal(text),\n};\n\n/**\n * Interval over decimal.js `Decimal` values — exact, continuous.\n *\n *   import { DecimalInterval } from \"xantiagoma/decimal\";\n *   import Decimal from \"decimal.js\";\n *\n *   const r = DecimalInterval.closed(new Decimal(\"0.1\"), new Decimal(\"0.3\"));\n *   r.length();        // 0.2   (exact — no float fuzz)\n *   r.toString();      // \"[0.1,0.3]\"\n *   r.contains(new Decimal(\"0.2\")); // true\n */\nexport const DecimalInterval: BoundIntervalType<Decimal> = defineIntervalType(decimalDomain);\n/** Instance type of {@link DecimalInterval}. */\nexport type DecimalInterval = InstanceType<typeof DecimalInterval>;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,MAAa,gBAAyC;CACpD,MAAM;CACN,UAAU,GAAG,MAAM,EAAE,IAAI,EAAE;CAC3B,UAAU,UAAU,MAAM,UAAU;CACpC,UAAU,OAAO,UAAU,MAAM,MAAM,MAAM,CAAC,UAAU;CACxD,MAAM,OAAO,UAAU,MAAM,KAAK,MAAM;CACxC,SAAS,UAAU,MAAM,UAAU;CACnC,QAAQ,SAAS,IAAI,QAAQ,KAAK;CACnC;;;;;;;;;;;;AAaD,MAAa,kBAA8C,mBAAmB,cAAc"}