functionalscript 0.43.0 → 0.44.0

package/fjs/cli/proof.f.js

@@ -1,111 +0,0 @@
-import { pure } from '../effects/module.f.js';
-import { defaultNodeProgramOptions, emptyState, virtual } from '../effects/node/virtual/module.f.js';
-import { dispatch } from './module.f.js';
-import { assert, assertEq } from '../asserts/module.f.js';
-const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
-const echoCommands = [
-    {
-        names: ['echo', 'e'],
-        description: 'Print the first argument',
-        handler: ({ args: [arg = ''] }) => pure(arg.length),
-    },
-];
-const run = (commands) => (args) => virtual(emptyState)(dispatch(commands)(makeOptions(args)));
-export const proof = {
-    knownCommand: () => {
-        const [, code] = run(echoCommands)(['echo', 'hello']);
-        assertEq(code, 5, ['expected length 5', code]);
-    },
-    alias: () => {
-        const [, code] = run(echoCommands)(['e', 'hi']);
-        assertEq(code, 2, ['expected length 2', code]);
-    },
-    noArgs: () => {
-        const [state, code] = run(echoCommands)([]);
-        assertEq(code, 1, ['expected exit 1', code]);
-        assert(state.stderr.length !== 0, 'expected error in stderr');
-    },
-    unknownCommand: () => {
-        const [state, code] = run(echoCommands)(['bogus']);
-        assertEq(code, 1, ['expected exit 1', code]);
-        assert(state.stderr.length !== 0, 'expected error in stderr');
-    },
-    help: () => {
-        const [state, code] = run(echoCommands)(['help']);
-        assertEq(code, 0, ['expected exit 0', code]);
-        assert(state.stdout.includes('echo'), 'expected command name in stdout');
-        assert(state.stdout.includes('help'), 'expected help entry in stdout');
-    },
-    errorIncludesAvailable: () => {
-        const [state] = run(echoCommands)(['bogus']);
-        assert(state.stderr.includes('echo'), 'expected available commands in error');
-    },
-    handlerReceivesRemainingArgs: () => {
-        const captured = [];
-        const commands = [{
-                names: ['grab'],
-                description: 'Capture args',
-                handler: ({ args }) => {
-                    captured.push(...args);
-                    return pure(0);
-                },
-            }];
-        run(commands)(['grab', 'a', 'b', 'c']);
-        assertEq(captured.join(','), 'a,b,c', ['unexpected args', captured]);
-    },
-    nestedCommands: () => {
-        const inner = [{
-                names: ['ping'],
-                description: 'Inner ping',
-                handler: () => pure(42),
-            }];
-        const outer = [{
-                names: ['sub'],
-                description: 'Subcommand group',
-                handler: inner,
-            }];
-        const [, code] = run(outer)(['sub', 'ping']);
-        assertEq(code, 42, ['expected 42', code]);
-    },
-    nestedHelp: () => {
-        const inner = [{
-                names: ['ping'],
-                description: 'Inner ping',
-                handler: () => pure(0),
-            }];
-        const outer = [{
-                names: ['sub'],
-                description: 'Subcommand group',
-                handler: inner,
-            }];
-        const [state, code] = run(outer)(['sub', 'help']);
-        assertEq(code, 0, ['expected exit 0', code]);
-        assert(state.stdout.includes('ping'), 'expected inner command in help');
-    },
-    prototypeNameIsUnknownCommand: () => {
-        const [state, code] = run(echoCommands)(['toString']);
-        assertEq(code, 1, ['expected exit 1 for prototype-name command', code]);
-        assert(state.stderr.includes('unknown command'), 'expected unknown-command error in stderr');
-    },
-    helpPrototypeSafe: () => {
-        const [state, code] = run(echoCommands)(['help', 'toString']);
-        assertEq(code, 0, ['expected exit 0, not a throw', code]);
-        assert(state.stdout.includes('echo'), 'expected top-level help for unknown target');
-    },
-    helpWithTarget: () => {
-        const inner = [{
-                names: ['ping'],
-                description: 'Inner ping',
-                handler: () => pure(0),
-            }];
-        const outer = [{
-                names: ['sub'],
-                description: 'Subcommand group',
-                handler: inner,
-            }];
-        const [state, code] = run(outer)(['help', 'sub']);
-        assertEq(code, 0, ['expected exit 0', code]);
-        assert(state.stdout.includes('ping'), 'expected inner command in help');
-        assert(!(state.stdout.includes('Subcommand group')), 'expected inner help, not outer');
-    },
-};

package/fjs/common/monoid/module.f.d.ts

@@ -1,126 +0,0 @@
-/**
- * Monoids: the `Monoid<T>` algebraic structure (identity plus associative
- * binary operation), `repeat`, which applies the operation `n` times using
- * exponentiation by squaring, and `fold`, which applies it across every element
- * of a list.
- *
- * @module
- */
-import type { Fold, Reduce } from '../../types/function/operator/module.f.ts';
-import { type List } from '../../types/list/module.f.ts';
-/**
- * Represents a monoid, an algebraic structure with a binary operation
- * and an identity (neutral) element.
- *
- * A monoid satisfies the following properties:
- * 1. **Associativity**: The operation must be associative.
- *    For all `a`, `b`, and `c` in the set, `(a operation b) operation c = a operation (b operation c)`.
- *    {@link https://en.wikipedia.org/wiki/Associative_property Learn more about associativity}.
- * 2. **Identity Element**: There exists an element (called the identity) such that,
- *    when combined with any other element under the operation, it leaves the other element unchanged.
- *    {@link https://en.wikipedia.org/wiki/Identity_element Learn more about identity elements}.
- *
- * Learn more about monoids: {@link https://en.wikipedia.org/wiki/Monoid}.
- *
- * @template T The type of the elements in the monoid.
- */
-export type Monoid<T> = {
-    /**
-     * The identity (neutral) element for the monoid.
-     * When combined with any value under the `operation`, it leaves the other value unchanged.
-     *
-     * Examples:
-     * - `0` for addition
-     * - `1` for multiplication
-     * - `""` for string concatenation
-     * - `[]` for array concatenation
-     *
-     * Learn more: {@link https://en.wikipedia.org/wiki/Identity_element}
-     */
-    readonly identity: T;
-    /**
-     * The associative binary operation of the monoid.
-     * Takes one value of type `T` and returns a function that takes another value of type `T`,
-     * producing a result of type `T`.
-     *
-     * Examples:
-     * - `(a, b) => a + b` for addition
-     * - `(a, b) => a * b` for multiplication
-     * - `(a, b) => a.concat(b)` for arrays or strings
-     *
-     * Learn more: {@link https://en.wikipedia.org/wiki/Binary_operation}
-     */
-    readonly operation: Reduce<T>;
-};
-/**
- * Repeats a monoid operation `n` times on the given element `a`.
- * This function efficiently performs the operation using exponentiation by squaring.
- *
- * @template T The type of the elements in the monoid.
- * @param monoid The monoid structure, including the identity and binary operation.
- * @returns A function that takes an element `a` and a repetition count `n`,
- * and returns the result of applying the operation `n` times.
- *
- * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
- *
- * @example
- *
- * ```ts
- * const add: Monoid<number> = {
- *     identity: 0,
- *     operation: a => b => a + b,
- * };
- *
- * const resultAdd = repeat(add)(10n)(2) // 20
- *
- * const concat: Monoid<string> = {
- *     identity: '',
- *     operation: a => b => a + b,
- * };
- *
- * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
- * ```
- */
-export declare const repeat: <T>({ identity, operation }: Monoid<T>) => Fold<bigint, T>;
-/**
- * Reduces a `List<T>` with the monoid's associative `operation`, seeded at its
- * `identity`. An empty list folds to `identity`.
- *
- * `fold` is the reduction companion of {@link repeat}: where `repeat` applies
- * the operation a fixed number of times to a single element, `fold` applies it
- * across every element of a list. Together they let list reductions such as
- * `sum`, `product`, and string `concat` be expressed directly as monoid folds,
- * so the identity paired with each operation is stated once at the call site
- * instead of hand-seeding a raw `reduce`.
- *
- * Like `repeat`, `fold` applies the operation **accumulator-first**:
- * `operation(accumulator)(element)`, seeded at `identity`, so
- * `[a, b, c]` folds to `((identity op a) op b) op c`. Left-to-right order is
- * therefore preserved and `fold` is correct for non-commutative monoids (e.g.
- * string concatenation as `a => b => a + b`). `list.reduce` calls its reducer
- * element-first, so the operation is `flip`ped before it is handed over.
- *
- * @template T The type of the elements in the monoid.
- * @param monoid The monoid structure, including the identity and binary operation.
- * @returns A function that reduces a `List<T>` to a single `T`.
- *
- * @example
- *
- * ```ts
- * const add: Monoid<number> = {
- *     identity: 0,
- *     operation: a => b => a + b,
- * };
- *
- * fold(add)([1, 2, 3, 4]) // 10
- * fold(add)([])           // 0
- *
- * const concat: Monoid<string> = {
- *     identity: '',
- *     operation: a => b => a + b,
- * };
- *
- * fold(concat)(['a', 'b', 'c']) // 'abc' — order preserved
- * ```
- */
-export declare const fold: <T>({ identity, operation }: Monoid<T>) => (list: List<T>) => T;

package/fjs/common/monoid/module.f.js

@@ -1,88 +0,0 @@
-import { reduce } from '../../types/list/module.f.js';
-import { flip } from '../../types/function/module.f.js';
-/**
- * Repeats a monoid operation `n` times on the given element `a`.
- * This function efficiently performs the operation using exponentiation by squaring.
- *
- * @template T The type of the elements in the monoid.
- * @param monoid The monoid structure, including the identity and binary operation.
- * @returns A function that takes an element `a` and a repetition count `n`,
- * and returns the result of applying the operation `n` times.
- *
- * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
- *
- * @example
- *
- * ```ts
- * const add: Monoid<number> = {
- *     identity: 0,
- *     operation: a => b => a + b,
- * };
- *
- * const resultAdd = repeat(add)(10n)(2) // 20
- *
- * const concat: Monoid<string> = {
- *     identity: '',
- *     operation: a => b => a + b,
- * };
- *
- * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
- * ```
- */
-export const repeat = ({ identity, operation }) => n => a => {
-    let ai = a;
-    let ni = n;
-    let result = identity;
-    while (true) {
-        if ((ni & 1n) !== 0n) {
-            result = operation(result)(ai);
-        }
-        ni >>= 1n;
-        if (ni === 0n) {
-            return result;
-        }
-        ai = operation(ai)(ai);
-    }
-};
-/**
- * Reduces a `List<T>` with the monoid's associative `operation`, seeded at its
- * `identity`. An empty list folds to `identity`.
- *
- * `fold` is the reduction companion of {@link repeat}: where `repeat` applies
- * the operation a fixed number of times to a single element, `fold` applies it
- * across every element of a list. Together they let list reductions such as
- * `sum`, `product`, and string `concat` be expressed directly as monoid folds,
- * so the identity paired with each operation is stated once at the call site
- * instead of hand-seeding a raw `reduce`.
- *
- * Like `repeat`, `fold` applies the operation **accumulator-first**:
- * `operation(accumulator)(element)`, seeded at `identity`, so
- * `[a, b, c]` folds to `((identity op a) op b) op c`. Left-to-right order is
- * therefore preserved and `fold` is correct for non-commutative monoids (e.g.
- * string concatenation as `a => b => a + b`). `list.reduce` calls its reducer
- * element-first, so the operation is `flip`ped before it is handed over.
- *
- * @template T The type of the elements in the monoid.
- * @param monoid The monoid structure, including the identity and binary operation.
- * @returns A function that reduces a `List<T>` to a single `T`.
- *
- * @example
- *
- * ```ts
- * const add: Monoid<number> = {
- *     identity: 0,
- *     operation: a => b => a + b,
- * };
- *
- * fold(add)([1, 2, 3, 4]) // 10
- * fold(add)([])           // 0
- *
- * const concat: Monoid<string> = {
- *     identity: '',
- *     operation: a => b => a + b,
- * };
- *
- * fold(concat)(['a', 'b', 'c']) // 'abc' — order preserved
- * ```
- */
-export const fold = ({ identity, operation }) => reduce(flip(operation))(identity);

package/fjs/common/monoid/proof.f.d.ts

@@ -1,9 +0,0 @@
-export declare const proof: {
-    numberAdd: () => void;
-    stringConcat: () => void;
-    fold: {
-        nonEmpty: () => void;
-        order: () => void;
-        empty: () => void;
-    };
-};

package/fjs/common/monoid/proof.f.js

@@ -1,48 +0,0 @@
-import { repeat, fold } from "./module.f.js";
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    numberAdd: () => {
-        const add = {
-            identity: 0,
-            operation: a => b => a + b,
-        };
-        const resultAdd = repeat(add)(10n)(2); // 20
-        assertEq(resultAdd, 20);
-        const id = repeat(add)(0n)(42);
-        assertEq(id, 0);
-    },
-    stringConcat: () => {
-        const concat = {
-            identity: '',
-            operation: a => b => a + b,
-        };
-        const resultConcat = repeat(concat)(3n)('ha'); // 'hahaha'
-        assertEq(resultConcat, 'hahaha');
-    },
-    fold: {
-        nonEmpty: () => {
-            const add = {
-                identity: 0,
-                operation: a => b => a + b,
-            };
-            assertEq(fold(add)([1, 2, 3, 4]), 10);
-        },
-        order: () => {
-            // a non-commutative monoid: `fold` must preserve left-to-right order
-            // (`((('' + 'a') + 'b') + 'c')`), not reverse it to `'cba'`.
-            const concat = {
-                identity: '',
-                operation: a => b => a + b,
-            };
-            assertEq(fold(concat)(['a', 'b', 'c']), 'abc');
-        },
-        empty: () => {
-            const concat = {
-                identity: '',
-                operation: a => b => a + b,
-            };
-            // an empty list folds to the identity
-            assertEq(fold(concat)([]), '');
-        },
-    }
-};

package/fjs/crypto/hmac/module.f.d.ts

@@ -1,29 +0,0 @@
-/**
- * Provides an implementation of HMAC (Hash-based Message Authentication Code).
- *
- * https://en.wikipedia.org/wiki/HMAC
- * https://www.rfc-editor.org/rfc/rfc2104
- *
- * @module
- *
- * @example
- *
- * ```ts
- * import { vec } from '../../types/bit_vec/module.f.ts'
- * import { msbUtf8 } from '../../text/module.f.ts'
- * import { sha256 } from '../sha2/module.f.ts'
- *
- * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
- * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
- * ```
- */
-import { type Reduce } from '../../types/bit_vec/module.f.ts';
-import { type Sha2 } from '../sha2/module.f.ts';
-/**
- * Generates an HMAC (Hash-based Message Authentication Code) using the specified hash function.
- *
- * @param hashFunc - The hash function implementation to use.
- * @returns - A function that takes a key and returns another function
- * that takes a message and computes the HMAC.
- */
-export declare const hmac: (hashFunc: Sha2) => Reduce;

package/fjs/crypto/hmac/module.f.js

@@ -1,56 +0,0 @@
-/**
- * Provides an implementation of HMAC (Hash-based Message Authentication Code).
- *
- * https://en.wikipedia.org/wiki/HMAC
- * https://www.rfc-editor.org/rfc/rfc2104
- *
- * @module
- *
- * @example
- *
- * ```ts
- * import { vec } from '../../types/bit_vec/module.f.ts'
- * import { msbUtf8 } from '../../text/module.f.ts'
- * import { sha256 } from '../sha2/module.f.ts'
- *
- * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
- * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
- * ```
- */
-import { length, msb, vec, vec8, repeat } from '../../types/bit_vec/module.f.js';
-import { computeSync } from '../sha2/module.f.js';
-const { concat, xor } = msb;
-/**
- * Outer padding.
- */
-const oPad = vec8(0x5cn);
-/**
- * Inner padding.
- */
-const iPad = vec8(0x36n);
-/**
- * Generates an HMAC (Hash-based Message Authentication Code) using the specified hash function.
- *
- * @param hashFunc - The hash function implementation to use.
- * @returns - A function that takes a key and returns another function
- * that takes a message and computes the HMAC.
- */
-export const hmac = (hashFunc) => {
-    const { blockLength } = hashFunc;
-    const p = repeat(blockLength >> 3n);
-    const ip = p(iPad);
-    const op = p(oPad);
-    const c = computeSync(hashFunc);
-    return k => {
-        const k1 = length(k) > blockLength ? c([k]) : k;
-        const k2 = concat(k1)(vec(blockLength - length(k1))(0n));
-        const xk2 = xor(k2);
-        const f = (p) => {
-            const x = xk2(p);
-            return (msg) => c([x, msg]);
-        };
-        const fip = f(ip);
-        const fop = f(op);
-        return m => fop(fip(m));
-    };
-};

package/fjs/crypto/hmac/proof.f.js

@@ -1,32 +0,0 @@
-import { assertEq } from '../../asserts/module.f.js';
-import { utf8 } from '../../text/module.f.js';
-import { uint, vec } from '../../types/bit_vec/module.f.js';
-import { sha256, sha384, sha512 } from '../sha2/module.f.js';
-import { hmac } from './module.f.js';
-export const proof = {
-    example: () => {
-        const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        assertEq(r, vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n));
-    },
-    sha256: () => {
-        const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        assertEq(uint(r), 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n, r);
-    },
-    sha384: () => {
-        const k = vec(384n)(0n);
-        const m = vec(904n)(0x0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010069c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbc9a9083505bc92276aec4be312696ef7bf3bf603f4bbd381196a029f340585312n);
-        const r = hmac(sha384)(k)(m);
-        assertEq(r, vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban), uint(r).toString(16));
-    },
-    sha512: () => {
-        const r = hmac(sha512)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        assertEq(r, vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an));
-    },
-    // RFC 4231 Test Case 6: key (131 bytes of 0xaa = 1048 bits) exceeds SHA-256 block size (512 bits),
-    // so the key is first compressed via the hash function before use.
-    longKey: () => {
-        const key = vec(1048n)(BigInt('0x' + 'aa'.repeat(131)));
-        const r = hmac(sha256)(key)(utf8('Test Using Larger Than Block-Size Key - Hash Key First'));
-        assertEq(uint(r), 0x60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54n);
-    }
-};

package/fjs/crypto/pow/module.f.d.ts

@@ -1,37 +0,0 @@
-import { type Vec } from '../../types/bit_vec/module.f.ts';
-import type { Nullable } from '../../types/nullable/module.f.ts';
-import { type Sha2 } from '../sha2/module.f.ts';
-/** Genesis-block compact target (`0x1d00ffff`). */
-export declare const genesisNBits = 486604799n;
-/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
-export declare const genesisTarget = 26959535291011309493156476344723991336010898738574164086137773096960n;
-/**
- * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
- *
- * - `exponent = nBits >> 24`
- * - `mantissa = nBits & 0xffffff`
- * - `target = mantissa × 2^(8 × (exponent − 3))`
- *
- * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
- * sign bit, overflow, target wider than 256 bits).
- *
- * @param nBits - Compact target encoding.
- * @returns Decoded target, or `null` when **nBits** is invalid.
- */
-export declare const targetFromNBits: (nBits: bigint) => Nullable<bigint>;
-export type Pow = {
-    /** Hash `data` with the configured `Sha2`; digest as big-endian uint256. */
-    readonly hashInt: (data: Vec) => bigint;
-    /** Whether `hashInt(data) <= targetFromNBits(nBits)`; `false` when **nBits** is invalid. */
-    readonly meets: (nBits: bigint) => (data: Vec) => boolean;
-};
-/**
- * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
- *
- * @param hash - SHA-2 configuration whose digest is compared as uint256.
- */
-export declare const pow: (hash: Sha2) => Pow;
-/** SHA-256 proof-of-work (`pow(sha256)`). */
-export declare const sha256Pow: Pow;
-/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
-export declare const bitcoinPow: Pow;

package/fjs/crypto/pow/module.f.js

@@ -1,72 +0,0 @@
-/**
- * Bitcoin-style proof-of-work: compact **nBits** target decoding and
- * hash-vs-target verification using an injected SHA-2 hash.
- *
- * @module
- */
-import { mask } from '../../types/bigint/module.f.js';
-import { uint } from '../../types/bit_vec/module.f.js';
-import { computeSync, sha256 } from '../sha2/module.f.js';
-const nBitsMantissa = mask(24n);
-const mantissaSign = 0x00800000n;
-const mantissaBody = 0x007fffffn;
-const exponentShift = 24n;
-const uint256Mask = mask(256n);
-/** Genesis-block compact target (`0x1d00ffff`). */
-export const genesisNBits = 0x1d00ffffn;
-/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
-export const genesisTarget = 0x00000000ffff0000000000000000000000000000000000000000000000000000n;
-const decodeShift = (exponent) => 8n * (exponent - 3n);
-const compactTarget = (exponent) => (mantissa) => {
-    const shift = decodeShift(exponent);
-    return shift >= 0n ? mantissa << shift : mantissa >> -shift;
-};
-const negativeNBits = (mantissa) => mantissa !== 0n && (mantissa & mantissaSign) !== 0n;
-const overflowNBits = (exponent) => (mantissa) => (target) => target !== 0n &&
-    (exponent > 34n || (mantissa !== 0n && (mantissa & mantissaBody) === 0n));
-/**
- * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
- *
- * - `exponent = nBits >> 24`
- * - `mantissa = nBits & 0xffffff`
- * - `target = mantissa × 2^(8 × (exponent − 3))`
- *
- * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
- * sign bit, overflow, target wider than 256 bits).
- *
- * @param nBits - Compact target encoding.
- * @returns Decoded target, or `null` when **nBits** is invalid.
- */
-export const targetFromNBits = (nBits) => {
-    const exponent = nBits >> exponentShift;
-    const mantissa = nBits & nBitsMantissa;
-    if (negativeNBits(mantissa)) {
-        return null;
-    }
-    const target = compactTarget(exponent)(mantissa);
-    if (overflowNBits(exponent)(mantissa)(target)) {
-        return null;
-    }
-    if (target > uint256Mask) {
-        return null;
-    }
-    return target;
-};
-/**
- * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
- *
- * @param hash - SHA-2 configuration whose digest is compared as uint256.
- */
-export const pow = (hash) => {
-    const c = computeSync(hash);
-    const hashInt = (data) => uint(c([data]));
-    const meets = (nBits) => (data) => {
-        const target = targetFromNBits(nBits);
-        return target !== null && hashInt(data) <= target;
-    };
-    return { hashInt, meets };
-};
-/** SHA-256 proof-of-work (`pow(sha256)`). */
-export const sha256Pow = pow(sha256);
-/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
-export const bitcoinPow = sha256Pow;