functionalscript 0.43.1 → 0.45.0

package/fjs/types/patricia_trie/proof.f.mjs

@@ -0,0 +1,151 @@
+/**
+ * @import { State } from './types.ts'
+ */
+
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { emptyState, patriciaTrie } from './module.f.mjs'
+
+/** @typedef {readonly [bigint, bigint, bigint][]} _NodeList */
+
+/** @type {(a: bigint, b: bigint) => bigint} */
+const combine = (a, b) => a * 1_000n + b
+
+/** @type {(a: bigint, b: bigint, s: _NodeList) => readonly [bigint, _NodeList]} */
+const create = (a, b, s) => {
+    const h = combine(a, b)
+    return [h, [...s, [a, b, h]]]
+}
+
+const { push, end } = patriciaTrie(create)
+
+/** @type {(state: State<_NodeList, bigint>) => readonly bigint[]} */
+const leaves = ([, candidates]) => candidates.map(([leaf]) => leaf)
+
+/** @type {(inputs: readonly bigint[], expectedLeaves: readonly (readonly bigint[])[], expectedNodeCounts: readonly number[]) => void} */
+const runExample = (inputs, expectedLeaves, expectedNodeCounts) => {
+    /** @type {State<_NodeList, bigint>} */
+    let state = emptyState([])
+    for (let i = 0; i < inputs.length; i++) {
+        const x = inputs[i]
+        const prevCount = state[0].length
+        state = push([x, x], state)
+
+        const actual = leaves(state)
+        assertEq(actual.length, expectedLeaves[i].length)
+        for (let j = 0; j < actual.length; j++) {
+            assertEq(actual[j], expectedLeaves[i][j])
+        }
+
+        const newNodes = state[0].slice(prevCount)
+        assertEq(newNodes.length, expectedNodeCounts[i])
+        for (const [l, r, h] of newNodes) { assertEq(h, combine(l, r)) }
+    }
+    const prevCount = state[0].length
+    const [root, finalStorage] = end(state)
+    const finalNodes = finalStorage.slice(prevCount)
+    assertEq(finalNodes.length, expectedLeaves[expectedLeaves.length - 1].length - 1)
+    assert(root !== undefined)
+    for (const [l, r, h] of finalNodes) { assertEq(h, combine(l, r)) }
+}
+
+const empty = () => {
+    const [root, storage] = end(emptyState([]))
+    assertEq(storage.length, 0)
+    assertEq(root, undefined)
+}
+
+const singleLeaf = () => {
+    const state = push([42n, 42n], emptyState([]))
+    assertEq(state[0].length, 0)
+    assertEq(leaves(state).length, 1)
+    assertEq(leaves(state)[0], 42n)
+
+    const [root, finalStorage] = end(state)
+    assertEq(finalStorage.length, 0)
+    assertEq(root, 42n)
+}
+
+const twoLeaves = () => {
+    const s1 = push([7n, 7n], emptyState([]))
+    const prevCount = s1[0].length
+    const s2 = push([3n, 3n], s1)
+    assertEq(s2[0].slice(prevCount).length, 0)
+    assertEq(leaves(s2).length, 2)
+
+    const prevCount2 = s2[0].length
+    const [root, finalStorage] = end(s2)
+    const finalNodes = finalStorage.slice(prevCount2)
+    assertEq(finalNodes.length, 1)
+    assertEq(finalNodes[0][0], 7n)
+    assertEq(finalNodes[0][1], 3n)
+    assertEq(finalNodes[0][2], combine(7n, 3n))
+    assertEq(root, combine(7n, 3n))
+}
+
+// example.md — descending
+// merges happen at: step 2 (1), 3 (1), 4 (1), 7 (2), 8 (2), A (1), C (2), F (1)
+const descending = () => runExample(
+    [
+        0b11111001n, 0b11110010n, 0b11100011n, 0b11001000n,
+        0b10110011n, 0b10100110n, 0b10100011n, 0b10011111n,
+        0b01110111n, 0b01101110n, 0b01011001n, 0b01001001n,
+        0b00100111n, 0b00010111n, 0b00010000n, 0b00001110n,
+    ],
+    [
+        [0b11111001n],
+        [0b11111001n, 0b11110010n],
+        [0b11110010n, 0b11100011n],
+        [0b11100011n, 0b11001000n],
+        [0b11001000n, 0b10110011n],
+        [0b11001000n, 0b10110011n, 0b10100110n],
+        [0b11001000n, 0b10110011n, 0b10100110n, 0b10100011n],
+        [0b11001000n, 0b10100011n, 0b10011111n],
+        [0b10011111n, 0b01110111n],
+        [0b10011111n, 0b01110111n, 0b01101110n],
+        [0b10011111n, 0b01101110n, 0b01011001n],
+        [0b10011111n, 0b01101110n, 0b01011001n, 0b01001001n],
+        [0b10011111n, 0b01001001n, 0b00100111n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010111n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010111n, 0b00010000n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010000n, 0b00001110n],
+    ],
+    [0, 0, 1, 1, 1, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1],
+)
+
+// example.md — ascending (same values, reversed)
+// merges happen at: step 3 (2), 4 (1), 6 (1), 8 (3), B (1), C (2)
+const ascending = () => runExample(
+    [
+        0b00001110n, 0b00010000n, 0b00010111n, 0b00100111n,
+        0b01001001n, 0b01011001n, 0b01101110n, 0b01110111n,
+        0b10011111n, 0b10100011n, 0b10100110n, 0b10110011n,
+        0b11001000n, 0b11100011n, 0b11110010n, 0b11111001n,
+    ],
+    [
+        [0b00001110n],
+        [0b00001110n, 0b00010000n],
+        [0b00001110n, 0b00010000n, 0b00010111n],
+        [0b00010111n, 0b00100111n],
+        [0b00100111n, 0b01001001n],
+        [0b00100111n, 0b01001001n, 0b01011001n],
+        [0b00100111n, 0b01011001n, 0b01101110n],
+        [0b00100111n, 0b01011001n, 0b01101110n, 0b01110111n],
+        [0b01110111n, 0b10011111n],
+        [0b01110111n, 0b10011111n, 0b10100011n],
+        [0b01110111n, 0b10011111n, 0b10100011n, 0b10100110n],
+        [0b01110111n, 0b10011111n, 0b10100110n, 0b10110011n],
+        [0b01110111n, 0b10110011n, 0b11001000n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n, 0b11110010n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n, 0b11110010n, 0b11111001n],
+    ],
+    [0, 0, 0, 2, 1, 0, 1, 0, 3, 0, 0, 1, 2, 0, 0, 0],
+)
+
+export const proof = {
+    empty,
+    singleLeaf,
+    twoLeaves,
+    descending,
+    ascending
+}

package/fjs/types/patricia_trie/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Types for the streaming Patricia trie.
+ *
+ * @module
+ */
+/**
+ * Merges two child identities into a parent. Values first, storage last in both
+ * params and return.
+ */
+export type Create<S, T> = (a: T, b: T, storage: S) => readonly [T, S];
+/**
+ * A leaf entry: `[sortKey, identity]`. The sort key is used only for XOR
+ * comparisons.
+ */
+export type Candidate<T> = readonly [bigint, T];
+export type InternalState<T> = readonly Candidate<T>[];
+/**
+ * Streaming state: `[storage, right-spine stack]`.
+ */
+export type State<S, T> = readonly [S, InternalState<T>];
+/**
+ * @property push
+ *
+ * Add one leaf. Merges any tightly-coupled stack candidates before pushing.
+ *
+ * @property end
+ *
+ * Drain the stack right-to-left, returning the root identity and final storage.
+ * Returns `undefined` as the root if no leaves were pushed.
+ */
+export type PatriciaTrie<S, T> = {
+    readonly push: (c: Candidate<T>, state: State<S, T>) => State<S, T>;
+    readonly end: (state: State<S, T>) => readonly [T | undefined, S];
+};

package/fjs/types/prime_field/module.f.d.mts

@@ -0,0 +1,44 @@
+/**
+ * Prime field arithmetic over `bigint`: `prime_field(p)` builds a `PrimeField`
+ * with negation, addition, subtraction, multiplication, division via modular
+ * inverse, and exponentiation; `sqrt` returns a square-root function when
+ * `p % 4 === 3`.
+ *
+ * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
+ */
+import type { Unary } from '../bigint/types.ts';
+import type { PrimeField } from './types.ts';
+/**
+ * Creates a prime field with the specified prime modulus and associated operations.
+ *
+ * @param {bigint} p A prime number to define the field.
+ * @returns {PrimeField} The prime field object.
+ */
+export declare const prime_field: (p: bigint) => PrimeField;
+/**
+ * Computes the square root of a number in a prime field.
+ *
+ * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
+ *
+ * @param {PrimeField} field
+ * @returns {(a: bigint) => bigint | null}
+ *
+ * @example
+ *
+ * ```js
+ * const field = prime_field(7n);
+ * const root = sqrt(field)(4n);
+ * if (root !== 2n) { throw root }
+ * ```
+ */
+export declare const sqrt: ({ p, pow, pow2 }: PrimeField) => (a: bigint) => bigint | null;
+/**
+ * Modular square root mod `p` (`p ≡ 3 (mod 4)`); uses {@link PrimeField.neg} when `x` is not a residue.
+ *
+ * @param {PrimeField} field
+ * @returns {Unary}
+ */
+export declare const modSqrt: (field: PrimeField) => Unary;

package/fjs/types/prime_field/module.f.mjs

@@ -0,0 +1,137 @@
+/**
+ * Prime field arithmetic over `bigint`: `prime_field(p)` builds a `PrimeField`
+ * with negation, addition, subtraction, multiplication, division via modular
+ * inverse, and exponentiation; `sqrt` returns a square-root function when
+ * `p % 4 === 3`.
+ *
+ * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
+ */
+
+import { repeat } from '../../common/monoid/module.f.mjs'
+import { assertNotNullish } from '../../asserts/module.f.mjs'
+
+/**
+ * Creates a prime field with the specified prime modulus and associated operations.
+ *
+ * @param {bigint} p A prime number to define the field.
+ * @returns {PrimeField} The prime field object.
+ */
+export const prime_field = p => {
+    /** @type {Reduce} */
+    const sub = a => b => {
+        const r = a - b
+        return r < 0 ? r + p : r
+    }
+    /** @type {Reduce} */
+    const mul = a => b => a * b % p
+    /** @type {Unary} */
+    const reciprocal = a => {
+        if (a === 0n) { throw '1/0' }
+        let a1 = a
+        let a0 = p
+        let f0 = 0n
+        let f1 = 1n
+        while (a1 !== 1n) {
+            const q = a0 / a1
+            const a2 = a0 % a1
+            a0 = a1
+            a1 = a2
+            const f2 = sub(f0)(mul(f1)(q))
+            f0 = f1
+            f1 = f2
+        }
+        return f1
+    }
+    const middle = p >> 1n
+    /** @type {Unary} */
+    const pow2 = a => mul(a)(a)
+    /** @type {Reduce} */
+    const pow = repeat({ identity: 1n, operation: mul })
+    /** @type {Reduce} */
+    const add = a => b => {
+        const r = a + b
+        return r < p ? r : r - p
+    }
+    /** @type {Unary} */
+    const reduce = x => {
+        const r = x % p
+        return r < 0n ? add(p)(r) : r
+    }
+    const max = p - 1n
+    // Euler's exponent is `(p - 1) / 2`; use `max`, not `p`, so `p === 2n`
+    // gives exponent `0n` instead of `1n`.
+    // 0 is a square mod p; Euler's criterion needs a separate case because 0^e = 0.
+    const powHalf = pow(max >> 1n)
+    /** @type {(x: bigint) => boolean} */
+    const quadRes = x => {
+        const v = reduce(x)
+        return v === 0n || powHalf(v) === 1n
+    }
+    return {
+        p,
+        middle,
+        max,
+        neg: a => a === 0n ? 0n : p - a,
+        sub,
+        add,
+        abs: a => middle < a ? p - a : a,
+        mul,
+        reciprocal,
+        div: a => b => mul(a)(reciprocal(b)),
+        pow,
+        pow2,
+        pow3: a => mul(a)(pow2(a)),
+        reduce,
+        quadRes,
+    }
+}
+
+/**
+ * Computes the square root of a number in a prime field.
+ *
+ * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
+ *
+ * @param {PrimeField} field
+ * @returns {(a: bigint) => bigint | null}
+ *
+ * @example
+ *
+ * ```js
+ * const field = prime_field(7n);
+ * const root = sqrt(field)(4n);
+ * if (root !== 2n) { throw root }
+ * ```
+ */
+export const sqrt = ({ p, pow, pow2 }) => {
+    if ((p & 3n) !== 3n) { throw 'sqrt' }
+    const sqrt_k = (p + 1n) >> 2n
+    const psk = pow(sqrt_k)
+    return a => {
+        const result = psk(a)
+        return pow2(result) === a ? result : null
+    }
+}
+
+/**
+ * Modular square root mod `p` (`p ≡ 3 (mod 4)`); uses {@link PrimeField.neg} when `x` is not a residue.
+ *
+ * @param {PrimeField} field
+ * @returns {Unary}
+ */
+export const modSqrt = field => {
+    const { neg, reduce } = field
+    const sqrt_p = sqrt(field)
+    return x => {
+        const v = reduce(x)
+        const r = sqrt_p(v)
+        // For a prime `p ≡ 3 (mod 4)`, `−1` is a non-residue, so exactly one of
+        // `±v` is a quadratic residue: if `v` has no root, `neg(v)` must — hence
+        // `s` is non-null. `sqrt` already enforces `p ≡ 3 (mod 4)`, but primality
+        // is never checked, so the only way to reach `s === null` is a *composite*
+        // modulus (where the residue argument breaks).
+        return r !== null ? r : assertNotNullish(sqrt_p(neg(v)), 'modSqrt')
+    }
+}

package/fjs/types/prime_field/proof.f.mjs

@@ -0,0 +1,131 @@
+import { modSqrt, prime_field, sqrt } from './module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+export const proof = {
+    throw: {
+        reciprocal_zero: () => prime_field(7n).reciprocal(0n),
+        sqrt_bad_prime: () => sqrt(prime_field(5n)),
+    },
+    prime_field_test: () => {
+        const p = 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn;
+        const f = prime_field(p)
+        const sqrt_f = sqrt(f)
+        return {
+            neg: () => {
+                assertEq(f.neg(0n), 0n)
+                assertEq(f.neg(1n), p - 1n)
+            },
+            sub: () => {
+                assertEq(f.sub(10n)(4n), 6n)
+                assertEq(f.sub(11n)(14n), p - 3n)
+            },
+            add: () => {
+                assertEq(f.add(13n)(24n), 37n)
+                assertEq(f.add(77n)(f.neg(12n)), 65n)
+            },
+            mul: () => {
+                assertEq(f.mul(100n)(0n), 0n)
+                assertEq(f.mul(101n)(205n), 20_705n)
+                assertEq(f.mul(304n)(f.neg(1n)), f.neg(304n))
+                assertEq(f.mul(f.neg(507n))(609n), f.neg(308_763n))
+                assertEq(f.mul(f.neg(713n))(f.neg(825n)), 588_225n)
+            },
+            reciprocal: () => {
+                let i = 1n
+                while (i < 10_000n) {
+                    assertEq(f.mul(f.reciprocal(i))(i), 1n)
+                    ++i
+                }
+            },
+            pow: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    assertEq(f.pow(0n)(a), 1n)
+                    assertEq(f.pow(1n)(a), a)
+                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+                    // a^(p-1) % p = 1
+                    assertEq(f.abs(f.pow(f.middle)(a)), 1n)
+                    assertEq(f.pow(f.sub(f.max)(1n))(a), f.reciprocal(a))
+                    assertEq(f.pow(f.max)(a), 1n)
+                }
+                // 0
+                assertEq(f.pow(0n)(0n), 1n)
+                assertEq(f.pow(f.max)(0n), 0n)
+                // 1
+                test(1n)
+                // 2
+                test(2n)
+                assertEq(f.pow(2n)(2n), 4n)
+                assertEq(f.pow(3n)(2n), 8n)
+                assertEq(f.pow(128n)(2n), 1n << 128n)
+                // 3
+                test(3n)
+                assertEq(f.pow(2n)(3n), 9n)
+                assertEq(f.pow(3n)(3n), 27n)
+                assertEq(f.pow(100n)(3n), 3n ** 100n)
+                assertEq(f.pow(110n)(3n), 3n ** 110n)
+                assertEq(f.pow(120n)(3n), 3n ** 120n)
+                assertEq(f.pow(121n)(3n), 3n ** 121n)
+                //
+                test(f.middle)
+                test(f.max - 1n)
+                test(f.max)
+            },
+            sqrtExample: () => {
+                const field = prime_field(7n);
+                assertEq(sqrt(field)(4n), 2n)
+            },
+            sqrt: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    const a2 = f.mul(a)(a)
+                    const s = sqrt_f(a2)
+                    assert(s === null || f.abs(s) === f.abs(a), 'sqrt')
+                }
+                let i = 1n
+                while (i < 1000n) {
+                    test(i)
+                    ++i;
+                }
+                test(f.middle);
+                test(f.max);
+            },
+            reduce: () => {
+                assertEq(f.reduce(13n), 13n)
+                assertEq(f.reduce(-1n), p - 1n)
+            },
+            quadRes: () => {
+                assert(f.quadRes(0n), 0n)
+                assert(f.quadRes(1n), 1n)
+                assert(f.quadRes(p), p)
+                assert(!f.quadRes(3n), 3n)
+                const f2 = prime_field(2n)
+                assert(f2.quadRes(0n), '0 mod 2')
+                assert(f2.quadRes(1n), '1 mod 2')
+            },
+            modSqrt: () => {
+                const root = modSqrt(f)
+                assertEq(root(4n), 2n)
+                assertEq(f.pow2(root(2n)), 2n)
+            },
+            div: () => {
+                assertEq(f.div(6n)(2n), 3n)
+                assertEq(f.div(0n)(5n), 0n)
+                assertEq(f.div(1n)(1n), 1n)
+            },
+            pow3: () => {
+                assertEq(f.pow3(0n), 0n)
+                assertEq(f.pow3(1n), 1n)
+                assertEq(f.pow3(2n), 8n)
+                assertEq(f.pow3(3n), 27n)
+                assertEq(f.pow3(10n), 1000n)
+            },
+            abs: () => {
+                assertEq(f.abs(0n), 0n)
+                assertEq(f.abs(1n), 1n)
+                assertEq(f.abs(f.neg(1n)), 1n)
+                assertEq(f.abs(f.middle), f.middle)
+            },
+        }
+    }
+}

package/fjs/types/prime_field/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Types for prime field arithmetic over `bigint`.
+ *
+ * @module
+ */
+import type { Reduce, Unary } from '../bigint/types.ts';
+/**
+ * A type representing a prime field and its associated operations.
+ *
+ * @property reduce
+ *
+ * Reduces an arbitrary `bigint` into `[0, p)`.
+ *
+ * @property quadRes
+ *
+ * `true` when `x` is a square modulo `p`, including `0`.
+ *
+ * Nonzero values are tested with Euler's criterion:
+ * `x^((p - 1) / 2) === 1 (mod p)`.
+ * For `p === 2n`, both field elements are squares.
+ */
+export type PrimeField = {
+    readonly p: bigint;
+    readonly middle: bigint;
+    readonly max: bigint;
+    readonly neg: Unary;
+    readonly sub: Reduce;
+    readonly add: Reduce;
+    readonly abs: Unary;
+    readonly mul: Reduce;
+    readonly reciprocal: Unary;
+    readonly div: Reduce;
+    readonly pow: Reduce;
+    readonly pow2: Unary;
+    readonly pow3: Unary;
+    readonly reduce: Unary;
+    readonly quadRes: (x: bigint) => boolean;
+};

package/fjs/types/range/module.f.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Range and interval utilities for numeric boundaries.
+ *
+ * @module
+ *
+ * @import { Range } from './types.ts'
+ */
+import type { Range } from './types.ts';
+/** @type {(...range: Range) => (i: number) => boolean} */
+export declare const contains: (...range: Range) => (i: number) => boolean;
+/** @type {(i: number) => Range} */
+export declare const one: (i: number) => Range;

package/fjs/types/range/module.f.mjs

@@ -0,0 +1,13 @@
+/**
+ * Range and interval utilities for numeric boundaries.
+ *
+ * @module
+ *
+ * @import { Range } from './types.ts'
+ */
+
+/** @type {(...range: Range) => (i: number) => boolean} */
+export const contains = (b, e) => i => b <= i && i <= e
+
+/** @type {(i: number) => Range} */
+export const one = a => [a, a]

package/fjs/types/range/proof.f.mjs

@@ -0,0 +1,10 @@
+import { contains } from './module.f.mjs'
+import { assert } from '../../asserts/module.f.mjs'
+
+export const proof = () => {
+    assert(contains(0, 5)(1), 1)
+    assert(contains(0, 5)(0), 0)
+    assert(contains(0, 5)(5), 5)
+    assert(!(contains(0, 5)(-1)), -1)
+    assert(!(contains(0, 5)(6)), 6)
+}

package/fjs/types/range/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Range and interval types for numeric boundaries.
+ *
+ * @module
+ */
+export type Range = readonly [number, number];

package/fjs/types/range_map/module.f.d.mts

@@ -0,0 +1,78 @@
+/**
+ * Utility functions and types for managing and merging range maps.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * const rmOps = rangeMap({
+ *     union: a => b => a | b,
+ *     equal: a => b => a === b,
+ *     def: 0,
+ * })
+ *
+ * // Create range maps
+ * const range1 = rmOps.fromRange(2)([0, 10])
+ * const range2 = rmOps.fromRange(5)([5, 15])
+ *
+ * // Merge range maps
+ * const merged = toArray(rmOps.merge(range1)(range2))
+ *
+ * // Retrieve values from the merged range map
+ * const get = rmOps.get(merged)
+ * //
+ * if (get(-1) !== 0) { throw 'error' }
+ * //
+ * if (get(0) !== 2) { throw 'error' }
+ * if (get(2) !== 2) { throw 'error' }
+ * // overlapped: 2 | 5 = 7
+ * if (get(7) !== 7) { throw 'error' }
+ * //
+ * if (get(12) !== 5) { throw 'error' }
+ * if (get(15) !== 5) { throw 'error' }
+ * //
+ * if (get(16) !== 0) { throw 'error' }
+ * ```
+ *
+ * @import { TailReduce, ReduceOp } from '../sorted_list/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { Equal } from '../function/operator/types.ts'
+ * @import { Range } from '../range/types.ts'
+ * @import { Entry, Properties, RangeMapArray, RangeMapOp, RangeMerge, } from './types.ts'
+ */
+import type { Nullable } from '../nullable/types.ts';
+import type { Range } from '../range/types.ts';
+import type { Entry, Properties, RangeMapArray, RangeMapOp, RangeMerge } from './types.ts';
+export type _RangeState<T> = Nullable<Entry<T>>;
+export declare const merge: <T>(
+/**
+ * @template T
+ * @param {Properties<T>} op
+ * @returns {RangeMerge<T>}
+ */
+op: Properties<T>) => RangeMerge<T>;
+export declare const get: <T>(
+/**
+ * @template T
+ * @param {T} def
+ */
+def: T) => (
+/** @param {RangeMapArray<T>} rm */
+rm: RangeMapArray<T>) => (value: number) => T;
+export declare const fromRange: <T>(
+/**
+ * @template T
+ * @param {T} def
+ */
+def: T) => (
+/** @param {T} v */
+v: T) => ([a, b]: Range) => RangeMapArray<T>;
+/**
+ * Creates a set of operations for managing range maps using the specified properties.
+ *
+ * @template T
+ * @param {Properties<T>} op The properties defining union and equality operations and the default value.
+ * @returns {RangeMapOp<T>} An object containing operations for merging, retrieving, and constructing range maps.
+ */
+export declare const rangeMap: <T>(op: Properties<T>) => RangeMapOp<T>;