@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/stdlib/numerics.js

@@ -0,0 +1,1356 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MachineNumericBox_key, _MachineNumericBox_payload;
+import { fromCompare } from './compare.js';
+import { Failure } from './failures.js';
+import { fromHashEq, stringHash } from './hash.js';
+import { err, ok } from './result.js';
+export class NumericOverflowFailure extends Failure {
+    constructor(leaf, operation) {
+        super(`Checked ${operation} overflowed for ${leaf}.`);
+        this.leaf = leaf;
+        this.operation = operation;
+    }
+}
+export class NumericDivisionByZeroFailure extends Failure {
+    constructor(leaf, operation) {
+        super(`Checked ${operation} divided ${leaf} by zero.`);
+        this.leaf = leaf;
+        this.operation = operation;
+    }
+}
+const MACHINE_KIND_PROPERTY = '__soundscript_numeric_kind';
+class MachineNumericBox {
+    constructor(kind, payload, key) {
+        _MachineNumericBox_key.set(this, void 0);
+        _MachineNumericBox_payload.set(this, void 0);
+        this.__soundscript_numeric_kind = kind;
+        __classPrivateFieldSet(this, _MachineNumericBox_key, key, "f");
+        __classPrivateFieldSet(this, _MachineNumericBox_payload, payload, "f");
+        Object.freeze(this);
+    }
+    payload() {
+        return __classPrivateFieldGet(this, _MachineNumericBox_payload, "f");
+    }
+    toJSON() {
+        return {
+            $numeric: this.__soundscript_numeric_kind,
+            value: formatPayload(__classPrivateFieldGet(this, _MachineNumericBox_payload, "f")),
+        };
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _MachineNumericBox_key, "f");
+    }
+    valueOf() {
+        throw new TypeError('Machine numerics do not support host numeric coercion.');
+    }
+    [(_MachineNumericBox_key = new WeakMap(), _MachineNumericBox_payload = new WeakMap(), Symbol.toPrimitive)](hint) {
+        if (hint === 'string') {
+            return __classPrivateFieldGet(this, _MachineNumericBox_key, "f");
+        }
+        throw new TypeError('Machine numerics do not support host numeric coercion.');
+    }
+}
+const MACHINE_NUMERIC_KINDS = new Set([
+    'f64',
+    'f32',
+    'i8',
+    'i16',
+    'i32',
+    'i64',
+    'u8',
+    'u16',
+    'u32',
+    'u64',
+]);
+const INTEGER_LEAF_KINDS = new Set([
+    'i8',
+    'i16',
+    'i32',
+    'i64',
+    'u8',
+    'u16',
+    'u32',
+    'u64',
+]);
+const FLOAT_LEAF_KINDS = new Set(['f32', 'f64']);
+const BIGINT_LEAF_KINDS = new Set(['i64', 'u64']);
+const NUMBER_LEAF_KINDS = new Set([
+    'f64',
+    'f32',
+    'i8',
+    'i16',
+    'i32',
+    'u8',
+    'u16',
+    'u32',
+]);
+const MACHINE_NUMERIC_CACHES = {
+    f64: new Map(),
+    f32: new Map(),
+    i8: new Map(),
+    i16: new Map(),
+    i32: new Map(),
+    i64: new Map(),
+    u8: new Map(),
+    u16: new Map(),
+    u32: new Map(),
+    u64: new Map(),
+};
+function isMachineNumericBox(value) {
+    return value instanceof MachineNumericBox;
+}
+function assertMachineNumeric(value) {
+    if (!isMachineNumericBox(value)) {
+        throw new TypeError('Expected a machine numeric value.');
+    }
+    return value;
+}
+function formatNumberPayload(value) {
+    if (Number.isNaN(value)) {
+        return 'NaN';
+    }
+    if (value === Infinity) {
+        return 'Infinity';
+    }
+    if (value === -Infinity) {
+        return '-Infinity';
+    }
+    return String(value);
+}
+function formatPayload(value) {
+    return typeof value === 'bigint' ? value.toString() : formatNumberPayload(value);
+}
+function keyForLeaf(kind, value) {
+    return `${kind}:${formatPayload(value)}`;
+}
+function canonicalizeFloat(value) {
+    if (Number.isNaN(value)) {
+        return Number.NaN;
+    }
+    if (Object.is(value, -0)) {
+        return 0;
+    }
+    return value;
+}
+function truncatedNumber(value) {
+    return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function payloadFromInput(value) {
+    return isMachineNumericBox(value) ? value.payload() : value;
+}
+function numberFromInput(value) {
+    const payload = payloadFromInput(value);
+    return typeof payload === 'bigint' ? Number(payload) : payload;
+}
+function bigintFromInput(value) {
+    const payload = payloadFromInput(value);
+    if (typeof payload === 'bigint') {
+        return payload;
+    }
+    return BigInt(truncatedNumber(payload));
+}
+function exactIntegralBigIntFromInput(value) {
+    if (isMachineNumericBox(value)) {
+        const payload = value.payload();
+        if (typeof payload === 'bigint') {
+            return payload;
+        }
+        if (Number.isInteger(payload)) {
+            return BigInt(payload);
+        }
+        return undefined;
+    }
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        return BigInt(value);
+    }
+    return undefined;
+}
+function canonicalizePayload(kind, value) {
+    switch (kind) {
+        case 'f64':
+            return canonicalizeFloat(numberFromInput(value));
+        case 'f32':
+            return canonicalizeFloat(Math.fround(numberFromInput(value)));
+        case 'i8':
+            return (truncatedNumber(numberFromInput(value)) << 24) >> 24;
+        case 'i16':
+            return (truncatedNumber(numberFromInput(value)) << 16) >> 16;
+        case 'i32':
+            return truncatedNumber(numberFromInput(value)) | 0;
+        case 'i64':
+            return BigInt.asIntN(64, bigintFromInput(value));
+        case 'u8':
+            return truncatedNumber(numberFromInput(value)) & 0xff;
+        case 'u16':
+            return truncatedNumber(numberFromInput(value)) & 0xffff;
+        case 'u32':
+            return truncatedNumber(numberFromInput(value)) >>> 0;
+        case 'u64':
+            return BigInt.asUintN(64, bigintFromInput(value));
+    }
+}
+function internMachineNumeric(kind, value) {
+    const payload = canonicalizePayload(kind, value);
+    const key = keyForLeaf(kind, payload);
+    const existing = MACHINE_NUMERIC_CACHES[kind].get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = new MachineNumericBox(kind, payload, key);
+    MACHINE_NUMERIC_CACHES[kind].set(key, created);
+    return created;
+}
+function numberLeafCompare(left, right) {
+    const leftValue = left.payload();
+    const rightValue = right.payload();
+    const leftNaN = Number.isNaN(leftValue);
+    const rightNaN = Number.isNaN(rightValue);
+    if (leftNaN || rightNaN) {
+        return leftNaN === rightNaN ? 0 : (leftNaN ? 1 : -1);
+    }
+    if (leftValue === rightValue) {
+        return 0;
+    }
+    if (leftValue === -Infinity) {
+        return -1;
+    }
+    if (rightValue === -Infinity) {
+        return 1;
+    }
+    if (leftValue === Infinity) {
+        return 1;
+    }
+    if (rightValue === Infinity) {
+        return -1;
+    }
+    return leftValue < rightValue ? -1 : 1;
+}
+function bigintLeafCompare(left, right) {
+    const leftValue = left.payload();
+    const rightValue = right.payload();
+    if (leftValue === rightValue) {
+        return 0;
+    }
+    return leftValue < rightValue ? -1 : 1;
+}
+function parseNumberText(text) {
+    const value = Number(text);
+    return Number.isNaN(value) && text.trim() !== 'NaN' ? undefined : value;
+}
+function parseBigIntText(text) {
+    try {
+        return BigInt(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function createIntegerFactory(kind, minValue, maxValue) {
+    const factory = ((value) => internMachineNumeric(kind, value));
+    Object.assign(factory, {
+        MAX_VALUE: internMachineNumeric(kind, maxValue),
+        MIN_VALUE: internMachineNumeric(kind, minValue),
+        compare(left, right) {
+            return BIGINT_LEAF_KINDS.has(kind)
+                ? bigintLeafCompare(left, right)
+                : numberLeafCompare(left, right);
+        },
+        format(value) {
+            return formatPayload(value.payload());
+        },
+        parse(text) {
+            const parsed = BIGINT_LEAF_KINDS.has(kind)
+                ? parseBigIntText(text)
+                : parseNumberText(text);
+            if (parsed === undefined) {
+                throw new TypeError(`Could not parse ${kind} from ${JSON.stringify(text)}.`);
+            }
+            return internMachineNumeric(kind, parsed);
+        },
+        tryParse(text) {
+            const parsed = BIGINT_LEAF_KINDS.has(kind)
+                ? parseBigIntText(text)
+                : parseNumberText(text);
+            return parsed === undefined
+                ? undefined
+                : internMachineNumeric(kind, parsed);
+        },
+        checkedAdd(left, right) {
+            return checkedIntegerBinary(kind, 'add', left, right);
+        },
+        checkedSub(left, right) {
+            return checkedIntegerBinary(kind, 'sub', left, right);
+        },
+        checkedMul(left, right) {
+            return checkedIntegerBinary(kind, 'mul', left, right);
+        },
+        checkedDiv(left, right) {
+            return checkedIntegerBinary(kind, 'div', left, right);
+        },
+        checkedRem(left, right) {
+            return checkedIntegerRemainder(kind, left, right);
+        },
+        checkedNeg(value) {
+            return checkedIntegerNegation(kind, value);
+        },
+    });
+    return factory;
+}
+function createFloatFactory(kind, minValue, maxValue) {
+    const factory = ((value) => internMachineNumeric(kind, value));
+    Object.assign(factory, {
+        MAX_VALUE: internMachineNumeric(kind, maxValue),
+        MIN_VALUE: internMachineNumeric(kind, minValue),
+        compare(left, right) {
+            return numberLeafCompare(left, right);
+        },
+        format(value) {
+            return formatPayload(value.payload());
+        },
+        isFinite(value) {
+            return Number.isFinite(value.payload());
+        },
+        isNaN(value) {
+            return Number.isNaN(value.payload());
+        },
+        parse(text) {
+            const parsed = parseNumberText(text);
+            if (parsed === undefined) {
+                throw new TypeError(`Could not parse ${kind} from ${JSON.stringify(text)}.`);
+            }
+            return internMachineNumeric(kind, parsed);
+        },
+        tryParse(text) {
+            const parsed = parseNumberText(text);
+            return parsed === undefined
+                ? undefined
+                : internMachineNumeric(kind, parsed);
+        },
+    });
+    return factory;
+}
+function exactKindGuard(kind) {
+    return (value) => isMachineNumericBox(value) && value.__soundscript_numeric_kind === kind;
+}
+function fitsIntegerKind(kind, value) {
+    const integral = exactIntegralBigIntFromInput(value);
+    if (integral === undefined) {
+        return false;
+    }
+    switch (kind) {
+        case 'i8':
+            return integral >= -128n && integral <= 127n;
+        case 'i16':
+            return integral >= -32768n && integral <= 32767n;
+        case 'i32':
+            return integral >= -2147483648n && integral <= 2147483647n;
+        case 'i64':
+            return BigInt.asIntN(64, integral) === integral;
+        case 'u8':
+            return integral >= 0n && integral <= 255n;
+        case 'u16':
+            return integral >= 0n && integral <= 65535n;
+        case 'u32':
+            return integral >= 0n && integral <= 4294967295n;
+        case 'u64':
+            return integral >= 0n && BigInt.asUintN(64, integral) === integral;
+    }
+}
+function fitsFloat32(value) {
+    const payload = isMachineNumericBox(value) ? value.payload() : value;
+    return typeof payload === 'number' && Number.isFinite(payload) && Math.fround(payload) === payload;
+}
+function assertIntegerLeafValue(kind, value) {
+    const numeric = assertMachineNumeric(value);
+    if (numeric.__soundscript_numeric_kind !== kind) {
+        throw new TypeError(`Expected ${kind} machine numeric value.`);
+    }
+    return numeric;
+}
+function integerPayloadToBigInt(numeric) {
+    const payload = numeric.payload();
+    return typeof payload === 'bigint' ? payload : BigInt(payload);
+}
+function checkedIntegerResult(kind, operation, value) {
+    if (!fitsIntegerKind(kind, value)) {
+        return err(new NumericOverflowFailure(kind, operation));
+    }
+    return ok(internMachineNumeric(kind, value));
+}
+function checkedIntegerBinary(kind, operation, left, right) {
+    const leftValue = integerPayloadToBigInt(assertIntegerLeafValue(kind, left));
+    const rightValue = integerPayloadToBigInt(assertIntegerLeafValue(kind, right));
+    if (operation === 'div' && rightValue === 0n) {
+        return err(new NumericDivisionByZeroFailure(kind, operation));
+    }
+    switch (operation) {
+        case 'add':
+            return checkedIntegerResult(kind, operation, leftValue + rightValue);
+        case 'sub':
+            return checkedIntegerResult(kind, operation, leftValue - rightValue);
+        case 'mul':
+            return checkedIntegerResult(kind, operation, leftValue * rightValue);
+        case 'div':
+            return checkedIntegerResult(kind, operation, leftValue / rightValue);
+    }
+}
+function checkedIntegerRemainder(kind, left, right) {
+    const leftValue = integerPayloadToBigInt(assertIntegerLeafValue(kind, left));
+    const rightValue = integerPayloadToBigInt(assertIntegerLeafValue(kind, right));
+    if (rightValue === 0n) {
+        return err(new NumericDivisionByZeroFailure(kind, 'rem'));
+    }
+    return ok(internMachineNumeric(kind, leftValue % rightValue));
+}
+function checkedIntegerNegation(kind, value) {
+    const payload = integerPayloadToBigInt(assertIntegerLeafValue(kind, value));
+    return checkedIntegerResult(kind, 'neg', -payload);
+}
+function exactShiftCount(value) {
+    return BigInt.asUintN(6, bigintFromInput(value));
+}
+function applyBigIntBinaryOperator(kind, operator, left, right) {
+    switch (operator) {
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            return left / right;
+        case '%':
+            return left % right;
+        case '**':
+            return left ** right;
+        case '&':
+            return left & right;
+        case '|':
+            return left | right;
+        case '^':
+            return left ^ right;
+        case '<<':
+            return left << exactShiftCount(right);
+        case '>>':
+            return left >> exactShiftCount(right);
+        case '>>>': {
+            const shifted = BigInt.asUintN(64, left) >> exactShiftCount(right);
+            return kind === 'u64' ? shifted : BigInt.asIntN(64, shifted);
+        }
+    }
+}
+function applyNumberBinaryOperator(operator, left, right) {
+    switch (operator) {
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            return left / right;
+        case '%':
+            return left % right;
+        case '**':
+            return left ** right;
+        case '&':
+            return left & right;
+        case '|':
+            return left | right;
+        case '^':
+            return left ^ right;
+        case '<<':
+            return left << right;
+        case '>>':
+            return left >> right;
+        case '>>>':
+            return left >>> right;
+    }
+}
+function applyNumberUnaryOperator(operator, value) {
+    switch (operator) {
+        case '+':
+            return +value;
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+function applyBigIntUnaryOperator(operator, value) {
+    switch (operator) {
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+export const F64 = createFloatFactory('f64', -Number.MAX_VALUE, Number.MAX_VALUE);
+export const F32 = createFloatFactory('f32', -3.4028234663852886e38, 3.4028234663852886e38);
+export const I8 = createIntegerFactory('i8', -128, 127);
+export const I16 = createIntegerFactory('i16', -32768, 32767);
+export const I32 = createIntegerFactory('i32', -2147483648, 2147483647);
+export const I64 = createIntegerFactory('i64', -9223372036854775808n, 9223372036854775807n);
+export const U8 = createIntegerFactory('u8', 0, 255);
+export const U16 = createIntegerFactory('u16', 0, 65535);
+export const U32 = createIntegerFactory('u32', 0, 4294967295);
+export const U64 = createIntegerFactory('u64', 0n, 18446744073709551615n);
+const FACTORY_BY_KIND = {
+    f64: F64,
+    f32: F32,
+    i8: I8,
+    i16: I16,
+    i32: I32,
+    i64: I64,
+    u8: U8,
+    u16: U16,
+    u32: U32,
+    u64: U64,
+};
+export function kindOf(value) {
+    if (isMachineNumericBox(value)) {
+        return value.__soundscript_numeric_kind;
+    }
+    return (typeof value);
+}
+export function isNumeric(value) {
+    return isMachineNumericBox(value);
+}
+export function isInt(value) {
+    return isMachineNumericBox(value) &&
+        INTEGER_LEAF_KINDS.has(value.__soundscript_numeric_kind);
+}
+export function isFloat(value) {
+    return isMachineNumericBox(value) &&
+        FLOAT_LEAF_KINDS.has(value.__soundscript_numeric_kind);
+}
+export const isF64 = exactKindGuard('f64');
+export const isF32 = exactKindGuard('f32');
+export const isI8 = exactKindGuard('i8');
+export const isI16 = exactKindGuard('i16');
+export const isI32 = exactKindGuard('i32');
+export const isI64 = exactKindGuard('i64');
+export const isU8 = exactKindGuard('u8');
+export const isU16 = exactKindGuard('u16');
+export const isU32 = exactKindGuard('u32');
+export const isU64 = exactKindGuard('u64');
+export function fitsF32(value) {
+    return fitsFloat32(value);
+}
+export function fitsI8(value) {
+    return fitsIntegerKind('i8', value);
+}
+export function fitsI16(value) {
+    return fitsIntegerKind('i16', value);
+}
+export function fitsI32(value) {
+    return fitsIntegerKind('i32', value);
+}
+export function fitsI64(value) {
+    return fitsIntegerKind('i64', value);
+}
+export function fitsU8(value) {
+    return fitsIntegerKind('u8', value);
+}
+export function fitsU16(value) {
+    return fitsIntegerKind('u16', value);
+}
+export function fitsU32(value) {
+    return fitsIntegerKind('u32', value);
+}
+export function fitsU64(value) {
+    return fitsIntegerKind('u64', value);
+}
+export function toHostNumber(value) {
+    const payload = assertMachineNumeric(value).payload();
+    return typeof payload === 'bigint' ? Number(payload) : payload;
+}
+export function toHostBigInt(value) {
+    const payload = assertMachineNumeric(value).payload();
+    return typeof payload === 'bigint' ? payload : BigInt(payload);
+}
+export function format(value) {
+    return isMachineNumericBox(value)
+        ? formatPayload(value.payload())
+        : formatPayload(value);
+}
+export function keyOf(value) {
+    return assertMachineNumeric(value).toString();
+}
+function readNumericFromDataView(kind, view, byteOffset, littleEndian) {
+    switch (kind) {
+        case 'f64':
+            return F64(view.getFloat64(byteOffset, littleEndian));
+        case 'f32':
+            return F32(view.getFloat32(byteOffset, littleEndian));
+        case 'i8':
+            return I8(view.getInt8(byteOffset));
+        case 'i16':
+            return I16(view.getInt16(byteOffset, littleEndian));
+        case 'i32':
+            return I32(view.getInt32(byteOffset, littleEndian));
+        case 'i64':
+            return I64(view.getBigInt64(byteOffset, littleEndian));
+        case 'u8':
+            return U8(view.getUint8(byteOffset));
+        case 'u16':
+            return U16(view.getUint16(byteOffset, littleEndian));
+        case 'u32':
+            return U32(view.getUint32(byteOffset, littleEndian));
+        case 'u64':
+            return U64(view.getBigUint64(byteOffset, littleEndian));
+    }
+}
+function writeNumericToDataView(kind, view, byteOffset, value, littleEndian) {
+    const numeric = FACTORY_BY_KIND[kind](value);
+    const payload = assertMachineNumeric(numeric).payload();
+    switch (kind) {
+        case 'f64':
+            view.setFloat64(byteOffset, payload, littleEndian);
+            return;
+        case 'f32':
+            view.setFloat32(byteOffset, payload, littleEndian);
+            return;
+        case 'i8':
+            view.setInt8(byteOffset, payload);
+            return;
+        case 'i16':
+            view.setInt16(byteOffset, payload, littleEndian);
+            return;
+        case 'i32':
+            view.setInt32(byteOffset, payload, littleEndian);
+            return;
+        case 'i64':
+            view.setBigInt64(byteOffset, payload, littleEndian);
+            return;
+        case 'u8':
+            view.setUint8(byteOffset, payload);
+            return;
+        case 'u16':
+            view.setUint16(byteOffset, payload, littleEndian);
+            return;
+        case 'u32':
+            view.setUint32(byteOffset, payload, littleEndian);
+            return;
+        case 'u64':
+            view.setBigUint64(byteOffset, payload, littleEndian);
+            return;
+    }
+}
+export function readF64(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('f64', view, byteOffset, littleEndian);
+}
+export function readF32(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('f32', view, byteOffset, littleEndian);
+}
+export function readI8(view, byteOffset) {
+    return readNumericFromDataView('i8', view, byteOffset);
+}
+export function readI16(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('i16', view, byteOffset, littleEndian);
+}
+export function readI32(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('i32', view, byteOffset, littleEndian);
+}
+export function readI64(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('i64', view, byteOffset, littleEndian);
+}
+export function readU8(view, byteOffset) {
+    return readNumericFromDataView('u8', view, byteOffset);
+}
+export function readU16(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('u16', view, byteOffset, littleEndian);
+}
+export function readU32(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('u32', view, byteOffset, littleEndian);
+}
+export function readU64(view, byteOffset, littleEndian) {
+    return readNumericFromDataView('u64', view, byteOffset, littleEndian);
+}
+export function writeF64(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('f64', view, byteOffset, value, littleEndian);
+}
+export function writeF32(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('f32', view, byteOffset, value, littleEndian);
+}
+export function writeI8(view, byteOffset, value) {
+    writeNumericToDataView('i8', view, byteOffset, value);
+}
+export function writeI16(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('i16', view, byteOffset, value, littleEndian);
+}
+export function writeI32(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('i32', view, byteOffset, value, littleEndian);
+}
+export function writeI64(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('i64', view, byteOffset, value, littleEndian);
+}
+export function writeU8(view, byteOffset, value) {
+    writeNumericToDataView('u8', view, byteOffset, value);
+}
+export function writeU16(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('u16', view, byteOffset, value, littleEndian);
+}
+export function writeU32(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('u32', view, byteOffset, value, littleEndian);
+}
+export function writeU64(view, byteOffset, value, littleEndian) {
+    writeNumericToDataView('u64', view, byteOffset, value, littleEndian);
+}
+function isCanonicalArrayIndexProperty(property) {
+    if (typeof property !== 'string' || property === '') {
+        return undefined;
+    }
+    const numeric = Number(property);
+    if (!Number.isInteger(numeric) || numeric < 0 || String(numeric) !== property) {
+        return undefined;
+    }
+    return numeric;
+}
+function normalizeViewIndex(index, length) {
+    return Number.isInteger(index) && index >= 0 && index < length ? index : undefined;
+}
+function resolveSubarrayIndex(index, length) {
+    if (index === undefined) {
+        return length;
+    }
+    if (index < 0) {
+        return Math.max(length + index, 0);
+    }
+    return Math.min(index, length);
+}
+function resolveSliceIndex(index, length) {
+    if (index === undefined) {
+        return 0;
+    }
+    if (index < 0) {
+        return Math.max(length + index, 0);
+    }
+    return Math.min(index, length);
+}
+function resolveLastSearchIndex(index, length) {
+    if (length === 0) {
+        return -1;
+    }
+    if (index === undefined) {
+        return length - 1;
+    }
+    if (index < 0) {
+        return length + index;
+    }
+    return Math.min(index, length - 1);
+}
+function materializeNumericLikeSource(source) {
+    if (Symbol.iterator in Object(source)) {
+        return Array.from(source);
+    }
+    const arrayLike = source;
+    const values = [];
+    for (let index = 0; index < arrayLike.length; index += 1) {
+        values.push(arrayLike[index]);
+    }
+    return values;
+}
+class MachineNumericArrayView {
+    constructor(buffer, bytesPerElement, byteOffset = 0, length) {
+        if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
+            throw new RangeError('byteOffset must be a non-negative integer.');
+        }
+        if (byteOffset % bytesPerElement !== 0) {
+            throw new RangeError('byteOffset must align to BYTES_PER_ELEMENT.');
+        }
+        if (byteOffset > buffer.byteLength) {
+            throw new RangeError('byteOffset is out of range for the provided buffer.');
+        }
+        const remaining = buffer.byteLength - byteOffset;
+        const computedLength = length ?? remaining / bytesPerElement;
+        if (!Number.isInteger(computedLength) || computedLength < 0) {
+            throw new RangeError('length must describe a whole number of elements.');
+        }
+        if (computedLength * bytesPerElement > remaining) {
+            throw new RangeError('length is out of range for the provided buffer.');
+        }
+        if (length === undefined && remaining % bytesPerElement !== 0) {
+            throw new RangeError('buffer byte length must align to BYTES_PER_ELEMENT.');
+        }
+        this.BYTES_PER_ELEMENT = bytesPerElement;
+        this.buffer = buffer;
+        this.byteOffset = byteOffset;
+        this.length = computedLength;
+        this.byteLength = computedLength * bytesPerElement;
+        this._view = new DataView(buffer, byteOffset, this.byteLength);
+        return new Proxy(this, {
+            get: (target, property, receiver) => {
+                const index = isCanonicalArrayIndexProperty(property);
+                if (index !== undefined) {
+                    return target.at(index);
+                }
+                const value = Reflect.get(target, property, receiver);
+                return typeof value === 'function' ? value.bind(target) : value;
+            },
+            set: (target, property, value, receiver) => {
+                const index = isCanonicalArrayIndexProperty(property);
+                if (index !== undefined) {
+                    target.setAt(index, value);
+                    return true;
+                }
+                return Reflect.set(target, property, value, receiver);
+            },
+        });
+    }
+    dataView() {
+        return this._view;
+    }
+    coerceToLeaf(value) {
+        return FACTORY_BY_KIND[this.leafKind()](value);
+    }
+    at(index) {
+        const normalized = normalizeViewIndex(index, this.length);
+        if (normalized === undefined) {
+            return undefined;
+        }
+        return this.readFromView(this._view, normalized * this.BYTES_PER_ELEMENT);
+    }
+    setAt(index, value) {
+        const normalized = normalizeViewIndex(index, this.length);
+        if (normalized === undefined) {
+            throw new RangeError('Index out of range for machine numeric view.');
+        }
+        this.writeToView(this._view, normalized * this.BYTES_PER_ELEMENT, value);
+    }
+    fill(value, start = 0, end = this.length) {
+        const startIndex = resolveSliceIndex(start, this.length);
+        const endIndex = resolveSubarrayIndex(end, this.length);
+        const finalEnd = Math.max(endIndex, startIndex);
+        for (let index = startIndex; index < finalEnd; index += 1) {
+            this.writeToView(this._view, index * this.BYTES_PER_ELEMENT, value);
+        }
+        return this;
+    }
+    set(source, offset = 0) {
+        if (!Number.isInteger(offset) || offset < 0 || offset > this.length) {
+            throw new RangeError('Offset out of range for machine numeric view.');
+        }
+        const snapshot = materializeNumericLikeSource(source);
+        if (offset + snapshot.length > this.length) {
+            throw new RangeError('Source is too large for machine numeric view.');
+        }
+        for (let index = 0; index < snapshot.length; index += 1) {
+            this.writeToView(this._view, (offset + index) * this.BYTES_PER_ELEMENT, snapshot[index]);
+        }
+    }
+    copyWithin(target, start, end) {
+        const targetIndex = resolveSliceIndex(target, this.length);
+        const startIndex = resolveSliceIndex(start, this.length);
+        const endIndex = resolveSubarrayIndex(end, this.length);
+        const available = Math.max(endIndex - startIndex, 0);
+        const count = Math.min(available, this.length - targetIndex);
+        const snapshot = [];
+        for (let index = 0; index < count; index += 1) {
+            snapshot.push(this.readFromView(this._view, (startIndex + index) * this.BYTES_PER_ELEMENT));
+        }
+        for (let index = 0; index < snapshot.length; index += 1) {
+            this.writeToView(this._view, (targetIndex + index) * this.BYTES_PER_ELEMENT, snapshot[index]);
+        }
+        return this;
+    }
+    *keys() {
+        for (let index = 0; index < this.length; index += 1) {
+            yield index;
+        }
+    }
+    values() {
+        return this[Symbol.iterator]();
+    }
+    *entries() {
+        for (let index = 0; index < this.length; index += 1) {
+            yield [index, this.readFromView(this._view, index * this.BYTES_PER_ELEMENT)];
+        }
+    }
+    includes(searchElement, fromIndex = 0) {
+        return this.indexOf(searchElement, fromIndex) !== -1;
+    }
+    indexOf(searchElement, fromIndex = 0) {
+        const startIndex = resolveSliceIndex(fromIndex, this.length);
+        const searchValue = this.coerceToLeaf(searchElement);
+        for (let index = startIndex; index < this.length; index += 1) {
+            if (this.readFromView(this._view, index * this.BYTES_PER_ELEMENT) === searchValue) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    lastIndexOf(searchElement, fromIndex) {
+        const startIndex = resolveLastSearchIndex(fromIndex, this.length);
+        if (startIndex < 0) {
+            return -1;
+        }
+        const searchValue = this.coerceToLeaf(searchElement);
+        for (let index = startIndex; index >= 0; index -= 1) {
+            if (this.readFromView(this._view, index * this.BYTES_PER_ELEMENT) === searchValue) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    slice(begin, end) {
+        const startIndex = resolveSliceIndex(begin, this.length);
+        const endIndex = resolveSubarrayIndex(end, this.length);
+        const finalLength = Math.max(endIndex - startIndex, 0);
+        const sliced = this.constructSubarray(new ArrayBuffer(finalLength * this.BYTES_PER_ELEMENT), 0, finalLength);
+        for (let index = 0; index < finalLength; index += 1) {
+            const value = this.readFromView(this._view, (startIndex + index) * this.BYTES_PER_ELEMENT);
+            sliced.setAt(index, value);
+        }
+        return sliced;
+    }
+    subarray(begin, end) {
+        const startIndex = resolveSubarrayIndex(begin ?? 0, this.length);
+        const endIndex = resolveSubarrayIndex(end, this.length);
+        const finalLength = Math.max(endIndex - startIndex, 0);
+        return this.constructSubarray(this.buffer, this.byteOffset + startIndex * this.BYTES_PER_ELEMENT, finalLength);
+    }
+    *[Symbol.iterator]() {
+        for (let index = 0; index < this.length; index += 1) {
+            yield this.readFromView(this._view, index * this.BYTES_PER_ELEMENT);
+        }
+    }
+}
+function assertLittleEndianNativeViewBridge(littleEndian, hostViewName) {
+    if (!littleEndian) {
+        throw new TypeError(`Native ${hostViewName} views require little-endian machine storage.`);
+    }
+}
+export class I8Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new I8Array(view.buffer, view.byteOffset, view.length);
+    }
+    constructor(buffer, byteOffset = 0, length) {
+        super(buffer, I8Array.BYTES_PER_ELEMENT, byteOffset, length);
+    }
+    leafKind() {
+        return 'i8';
+    }
+    readFromView(view, byteOffset) {
+        return readI8(view, byteOffset);
+    }
+    writeToView(view, byteOffset, value) {
+        writeI8(view, byteOffset, value);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new I8Array(buffer, byteOffset, length);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        return new Int8Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+I8Array.BYTES_PER_ELEMENT = 1;
+export class U8Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new U8Array(view.buffer, view.byteOffset, view.length);
+    }
+    constructor(buffer, byteOffset = 0, length) {
+        super(buffer, U8Array.BYTES_PER_ELEMENT, byteOffset, length);
+    }
+    leafKind() {
+        return 'u8';
+    }
+    readFromView(view, byteOffset) {
+        return readU8(view, byteOffset);
+    }
+    writeToView(view, byteOffset, value) {
+        writeU8(view, byteOffset, value);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new U8Array(buffer, byteOffset, length);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        return new Uint8Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+U8Array.BYTES_PER_ELEMENT = 1;
+export class I16Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new I16Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, I16Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'i16';
+    }
+    readFromView(view, byteOffset) {
+        return readI16(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeI16(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new I16Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Int16Array');
+        return new Int16Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+I16Array.BYTES_PER_ELEMENT = 2;
+export class U16Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new U16Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, U16Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'u16';
+    }
+    readFromView(view, byteOffset) {
+        return readU16(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeU16(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new U16Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Uint16Array');
+        return new Uint16Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+U16Array.BYTES_PER_ELEMENT = 2;
+export class I32Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new I32Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, I32Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'i32';
+    }
+    readFromView(view, byteOffset) {
+        return readI32(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeI32(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new I32Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Int32Array');
+        return new Int32Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+I32Array.BYTES_PER_ELEMENT = 4;
+export class U32Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new U32Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, U32Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'u32';
+    }
+    readFromView(view, byteOffset) {
+        return readU32(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeU32(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new U32Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Uint32Array');
+        return new Uint32Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+U32Array.BYTES_PER_ELEMENT = 4;
+export class I64Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new I64Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, I64Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'i64';
+    }
+    readFromView(view, byteOffset) {
+        return readI64(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeI64(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new I64Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'BigInt64Array');
+        return new BigInt64Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+I64Array.BYTES_PER_ELEMENT = 8;
+export class U64Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new U64Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, U64Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'u64';
+    }
+    readFromView(view, byteOffset) {
+        return readU64(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeU64(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new U64Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'BigUint64Array');
+        return new BigUint64Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+U64Array.BYTES_PER_ELEMENT = 8;
+export class F32Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new F32Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, F32Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'f32';
+    }
+    readFromView(view, byteOffset) {
+        return readF32(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeF32(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new F32Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Float32Array');
+        return new Float32Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+F32Array.BYTES_PER_ELEMENT = 4;
+export class F64Array extends MachineNumericArrayView {
+    static fromHostView(view) {
+        return new F64Array(view.buffer, view.byteOffset, view.length, true);
+    }
+    constructor(buffer, byteOffset = 0, length, littleEndian = true) {
+        super(buffer, F64Array.BYTES_PER_ELEMENT, byteOffset, length);
+        this._littleEndian = littleEndian;
+    }
+    leafKind() {
+        return 'f64';
+    }
+    readFromView(view, byteOffset) {
+        return readF64(view, byteOffset, this._littleEndian);
+    }
+    writeToView(view, byteOffset, value) {
+        writeF64(view, byteOffset, value, this._littleEndian);
+    }
+    constructSubarray(buffer, byteOffset, length) {
+        return new F64Array(buffer, byteOffset, length, this._littleEndian);
+    }
+    subarray(begin, end) {
+        return super.subarray(begin, end);
+    }
+    slice(begin, end) {
+        return super.slice(begin, end);
+    }
+    toHostView() {
+        assertLittleEndianNativeViewBridge(this._littleEndian, 'Float64Array');
+        return new Float64Array(this.buffer, this.byteOffset, this.length);
+    }
+}
+F64Array.BYTES_PER_ELEMENT = 8;
+export function equalAs(leaf, left, right) {
+    return leaf(left) === leaf(right);
+}
+export function compareAs(leaf, left, right) {
+    return leaf.compare(leaf(left), leaf(right));
+}
+export function eqAs(leaf) {
+    return {
+        equals(left, right) {
+            return equalAs(leaf, left, right);
+        },
+    };
+}
+export function orderAs(leaf) {
+    return fromCompare((left, right) => compareAs(leaf, left, right));
+}
+export function hashEqAs(leaf) {
+    return fromHashEq((value) => stringHash.hash(keyOf(leaf(value))), (left, right) => equalAs(leaf, left, right));
+}
+export function minAs(leaf, values) {
+    let smallest;
+    for (const value of values) {
+        const coerced = leaf(value);
+        if (!smallest || leaf.compare(coerced, smallest) < 0) {
+            smallest = coerced;
+        }
+    }
+    return smallest;
+}
+export function maxAs(leaf, values) {
+    let largest;
+    for (const value of values) {
+        const coerced = leaf(value);
+        if (!largest || leaf.compare(coerced, largest) > 0) {
+            largest = coerced;
+        }
+    }
+    return largest;
+}
+export function clampAs(leaf, value, minimum, maximum) {
+    const minValue = leaf(minimum);
+    const maxValue = leaf(maximum);
+    if (leaf.compare(minValue, maxValue) > 0) {
+        throw new RangeError('Expected clamp minimum to be less than or equal to clamp maximum.');
+    }
+    const coerced = leaf(value);
+    if (leaf.compare(coerced, minValue) < 0) {
+        return minValue;
+    }
+    if (leaf.compare(coerced, maxValue) > 0) {
+        return maxValue;
+    }
+    return coerced;
+}
+export function binarySearchAs(leaf, values, target) {
+    const targetValue = leaf(target);
+    let low = 0;
+    let high = values.length - 1;
+    let foundIndex = -1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const midValue = leaf(values[mid]);
+        const ordering = leaf.compare(midValue, targetValue);
+        if (ordering < 0) {
+            low = mid + 1;
+            continue;
+        }
+        if (ordering > 0) {
+            high = mid - 1;
+            continue;
+        }
+        foundIndex = mid;
+        high = mid - 1;
+    }
+    return foundIndex;
+}
+export function __numericBinary(operator, left, right) {
+    const leftValue = assertMachineNumeric(left);
+    const rightValue = assertMachineNumeric(right);
+    const kind = leftValue.__soundscript_numeric_kind;
+    if (kind !== rightValue.__soundscript_numeric_kind) {
+        throw new TypeError('Mixed machine numeric operators require explicit coercion.');
+    }
+    if (BIGINT_LEAF_KINDS.has(kind)) {
+        const result = applyBigIntBinaryOperator(kind, operator, leftValue.payload(), rightValue.payload());
+        return internMachineNumeric(kind, result);
+    }
+    const result = applyNumberBinaryOperator(operator, leftValue.payload(), rightValue.payload());
+    return internMachineNumeric(kind, result);
+}
+export function __numericUnary(operator, value) {
+    const numeric = assertMachineNumeric(value);
+    const kind = numeric.__soundscript_numeric_kind;
+    if (BIGINT_LEAF_KINDS.has(kind)) {
+        if (operator === '+') {
+            throw new TypeError('Unary plus is not supported on bigint-backed machine numerics.');
+        }
+        return internMachineNumeric(kind, applyBigIntUnaryOperator(operator, numeric.payload()));
+    }
+    return internMachineNumeric(kind, applyNumberUnaryOperator(operator, numeric.payload()));
+}
+export function __numericWasmLeaf(value) {
+    return value;
+}