@opencode/codemode 2.0.1 → 2.0.2

package/dist/stdlib/date.js

@@ -1,36 +1,24 @@
 import { Effect } from "effect";
-import { HostFunction, sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
-import { toPrimitive } from "../interpreter/runner.js";
-import { Values } from "../values.js";
+import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
+import { rangeError } from "../interpreter/model.js";
+import { ProgramDate, ProgramObject } from "../interpreter/objects.js";
+import { toPrimitive, toPrimitiveNumber } from "../interpreter/runner.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const dateSetterArguments = new Map([
-    ["setTime", 1],
-    ["setMilliseconds", 1],
-    ["setUTCMilliseconds", 1],
-    ["setSeconds", 2],
-    ["setUTCSeconds", 2],
-    ["setMinutes", 3],
-    ["setUTCMinutes", 3],
-    ["setHours", 4],
-    ["setUTCHours", 4],
-    ["setDate", 1],
-    ["setUTCDate", 1],
-    ["setMonth", 2],
-    ["setUTCMonth", 2],
-    ["setFullYear", 3],
-    ["setUTCFullYear", 3],
-]);
-export const dateMethods = new Set([
-    "getTime",
-    "valueOf",
-    "toISOString",
-    "toJSON",
-    "toString",
-    "toDateString",
-    "toTimeString",
-    "toUTCString",
-    "toGMTString",
+const constructDate = (runner, args, proto, node) => {
+    if (args.length === 0)
+        return Effect.succeed(new ProgramDate(proto, Date.now()));
+    if (args.length === 1) {
+        const arg = args[0];
+        if (arg instanceof ProgramDate)
+            return Effect.succeed(new ProgramDate(proto, arg.time));
+        return Effect.map(toPrimitive(runner, arg, "default", node), (value) => typeof value === "string"
+            ? new ProgramDate(proto, Date.parse(value))
+            : new ProgramDate(proto, new Date(coerceToNumber(value)).getTime()));
+    }
+    const parts = args.map((arg) => coerceToNumber(arg));
+    return Effect.succeed(new ProgramDate(proto, new Date(...parts).getTime()));
+};
+const getters = [
     "getFullYear",
     "getMonth",
     "getDate",
@@ -48,161 +36,78 @@ export const dateMethods = new Set([
     "getUTCSeconds",
     "getUTCMilliseconds",
     "getTimezoneOffset",
-    ...dateSetterArguments.keys(),
-]);
-const constructDate = (runner, args, node) => {
-    if (args.length === 0)
-        return Effect.succeed(new Values.Date(Date.now()));
-    if (args.length === 1) {
-        const arg = args[0];
-        if (arg instanceof Values.Date)
-            return Effect.succeed(new Values.Date(arg.time));
-        return Effect.map(toPrimitive(runner, arg, "number", node), (value) => typeof value === "string"
-            ? new Values.Date(Date.parse(value))
-            : new Values.Date(new Date(coerceToNumber(value)).getTime()));
-    }
-    const parts = args.map((arg) => coerceToNumber(arg));
-    return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
-};
-export const dateGlobal = (runner) => new HostFunction({
-    name: "Date",
-    // ISO instead of the host's locale string: date strings are deterministic and must not leak the host timezone.
-    call: () => Effect.sync(() => new Date().toISOString()),
-    construct: (args, node) => constructDate(runner, args, node),
-    instanceOf: (value) => value instanceof Values.Date,
-    members: {
-        now: sync("Date.now", () => Date.now()),
-        parse: sync("Date.parse", (args) => Date.parse(coerceToString(args[0]))),
-        UTC: sync("Date.UTC", (args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))),
-    },
-});
-export const dateSetterArgumentCount = (name) => dateSetterArguments.get(name);
-export const invokeDateMethod = (value, name, args, node, initialTime = value.time) => {
-    const hosted = new Date(initialTime);
-    switch (name) {
-        case "getTime":
-        case "valueOf":
-            return value.time;
-        case "toISOString":
-            if (!Number.isFinite(value.time))
-                throw rangeError("Invalid time value.", node);
-            return hosted.toISOString();
-        case "toJSON":
-            return Number.isFinite(value.time) ? hosted.toISOString() : null;
-        case "toString":
-            return coerceToString(value);
-        case "toDateString":
-            return hosted.toDateString();
-        case "toTimeString":
-            return hosted.toTimeString();
-        case "toUTCString":
-        case "toGMTString":
-            return hosted.toUTCString();
-        case "getFullYear":
-            return hosted.getFullYear();
-        case "getMonth":
-            return hosted.getMonth();
-        case "getDate":
-            return hosted.getDate();
-        case "getDay":
-            return hosted.getDay();
-        case "getHours":
-            return hosted.getHours();
-        case "getMinutes":
-            return hosted.getMinutes();
-        case "getSeconds":
-            return hosted.getSeconds();
-        case "getMilliseconds":
-            return hosted.getMilliseconds();
-        case "getUTCFullYear":
-            return hosted.getUTCFullYear();
-        case "getUTCMonth":
-            return hosted.getUTCMonth();
-        case "getUTCDate":
-            return hosted.getUTCDate();
-        case "getUTCDay":
-            return hosted.getUTCDay();
-        case "getUTCHours":
-            return hosted.getUTCHours();
-        case "getUTCMinutes":
-            return hosted.getUTCMinutes();
-        case "getUTCSeconds":
-            return hosted.getUTCSeconds();
-        case "getUTCMilliseconds":
-            return hosted.getUTCMilliseconds();
-        case "getTimezoneOffset":
-            return hosted.getTimezoneOffset();
-        case "setTime":
-            return updateDate(value, hosted.setTime(args[0]));
-        case "setMilliseconds":
-            return updateDate(value, hosted.setMilliseconds(args[0]));
-        case "setUTCMilliseconds":
-            return updateDate(value, hosted.setUTCMilliseconds(args[0]));
-        case "setSeconds":
-            if (args.length < 2)
-                return updateDate(value, hosted.setSeconds(args[0]));
-            return updateDate(value, hosted.setSeconds(args[0], args[1]));
-        case "setUTCSeconds":
-            if (args.length < 2)
-                return updateDate(value, hosted.setUTCSeconds(args[0]));
-            return updateDate(value, hosted.setUTCSeconds(args[0], args[1]));
-        case "setMinutes":
-            if (args.length < 2)
-                return updateDate(value, hosted.setMinutes(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setMinutes(args[0], args[1]));
-            return updateDate(value, hosted.setMinutes(args[0], args[1], args[2]));
-        case "setUTCMinutes":
-            if (args.length < 2)
-                return updateDate(value, hosted.setUTCMinutes(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setUTCMinutes(args[0], args[1]));
-            return updateDate(value, hosted.setUTCMinutes(args[0], args[1], args[2]));
-        case "setHours":
-            if (args.length < 2)
-                return updateDate(value, hosted.setHours(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setHours(args[0], args[1]));
-            if (args.length < 4)
-                return updateDate(value, hosted.setHours(args[0], args[1], args[2]));
-            return updateDate(value, hosted.setHours(args[0], args[1], args[2], args[3]));
-        case "setUTCHours":
-            if (args.length < 2)
-                return updateDate(value, hosted.setUTCHours(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setUTCHours(args[0], args[1]));
-            if (args.length < 4)
-                return updateDate(value, hosted.setUTCHours(args[0], args[1], args[2]));
-            return updateDate(value, hosted.setUTCHours(args[0], args[1], args[2], args[3]));
-        case "setDate":
-            return updateDate(value, hosted.setDate(args[0]));
-        case "setUTCDate":
-            return updateDate(value, hosted.setUTCDate(args[0]));
-        case "setMonth":
-            if (args.length < 2)
-                return updateDate(value, hosted.setMonth(args[0]));
-            return updateDate(value, hosted.setMonth(args[0], args[1]));
-        case "setUTCMonth":
-            if (args.length < 2)
-                return updateDate(value, hosted.setUTCMonth(args[0]));
-            return updateDate(value, hosted.setUTCMonth(args[0], args[1]));
-        case "setFullYear":
-            if (args.length < 2)
-                return updateDate(value, hosted.setFullYear(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setFullYear(args[0], args[1]));
-            return updateDate(value, hosted.setFullYear(args[0], args[1], args[2]));
-        case "setUTCFullYear":
-            if (args.length < 2)
-                return updateDate(value, hosted.setUTCFullYear(args[0]));
-            if (args.length < 3)
-                return updateDate(value, hosted.setUTCFullYear(args[0], args[1]));
-            return updateDate(value, hosted.setUTCFullYear(args[0], args[1], args[2]));
-        default:
-            throw new InterpreterRuntimeError(`Date method '${name}' is not available.`, node);
-    }
-};
-const updateDate = (value, time) => {
-    value.time = time;
-    return time;
+];
+const setters = [
+    ["setTime", 1],
+    ["setMilliseconds", 1],
+    ["setUTCMilliseconds", 1],
+    ["setSeconds", 2],
+    ["setUTCSeconds", 2],
+    ["setMinutes", 3],
+    ["setUTCMinutes", 3],
+    ["setHours", 4],
+    ["setUTCHours", 4],
+    ["setDate", 1],
+    ["setUTCDate", 1],
+    ["setMonth", 2],
+    ["setUTCMonth", 2],
+    ["setFullYear", 3],
+    ["setUTCFullYear", 3],
+];
+export const dateGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const proto = protos.Date;
+    const date = constructor(protos, proto, {
+        name: "Date",
+        length: 7,
+        // ISO instead of the host's locale string: date strings are deterministic and must not leak the host timezone.
+        call: () => Effect.sync(() => new Date().toISOString()),
+        construct: (args, newTarget, node) => constructDate(runner, args, prototypeFrom(newTarget, proto), node),
+    });
+    methods(protos, date, [
+        ["now", 0, () => Date.now()],
+        ["parse", 1, (_, args) => Date.parse(coerceToString(args[0]))],
+        ["UTC", 7, (_, args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))],
+    ]);
+    const self = (thisValue, name, node) => receiver(ProgramDate, thisValue, `Date.prototype.${name}`, node);
+    const iso = (value, node) => {
+        if (!Number.isFinite(value.time))
+            throw rangeError("Invalid time value.", node);
+        return new Date(value.time).toISOString();
+    };
+    methods(protos, proto, [
+        ["getTime", 0, (thisValue, _, node) => self(thisValue, "getTime", node).time],
+        ["valueOf", 0, (thisValue, _, node) => self(thisValue, "valueOf", node).time],
+        ["toISOString", 0, (thisValue, _, node) => iso(self(thisValue, "toISOString", node), node)],
+        [
+            "toJSON",
+            1,
+            (thisValue, _, node) => {
+                const value = self(thisValue, "toJSON", node);
+                return Number.isFinite(value.time) ? iso(value, node) : null;
+            },
+        ],
+        ["toString", 0, (thisValue, _, node) => coerceToString(self(thisValue, "toString", node))],
+        ["toDateString", 0, (thisValue, _, node) => new Date(self(thisValue, "toDateString", node).time).toDateString()],
+        ["toTimeString", 0, (thisValue, _, node) => new Date(self(thisValue, "toTimeString", node).time).toTimeString()],
+        ["toUTCString", 0, (thisValue, _, node) => new Date(self(thisValue, "toUTCString", node).time).toUTCString()],
+        ["toGMTString", 0, (thisValue, _, node) => new Date(self(thisValue, "toGMTString", node).time).toUTCString()],
+        ...getters.map((name) => [name, 0, (thisValue, _, node) => new Date(self(thisValue, name, node).time)[name]()]),
+        ...setters.map(([name, length]) => [
+            name,
+            length,
+            (thisValue, args, node) => {
+                const target = self(thisValue, name, node);
+                // Native setters read the current time before argument coercion, whose callbacks may mutate the Date.
+                const hosted = new Date(target.time);
+                return Effect.map(Effect.forEach(args.slice(0, length), (arg) => toPrimitiveNumber(runner, arg, node), {
+                    concurrency: 1,
+                }), (values) => {
+                    target.time = hosted[name](...values);
+                    return target.time;
+                });
+            },
+        ]),
+    ]);
+    return date;
 };

package/dist/stdlib/json.d.ts

@@ -1,3 +1,3 @@
-import { HostNamespace } from "../interpreter/host.js";
 import { type Runner } from "../interpreter/runner.js";
-export declare const jsonGlobal: <R>(runner: Runner<R>) => HostNamespace;
+import { ProgramObject } from "../interpreter/objects.js";
+export declare const jsonGlobal: <R>(runner: Runner<R>) => ProgramObject;

package/dist/stdlib/json.js

@@ -1,22 +1,25 @@
 import { Effect } from "effect";
-import { HostFunction, HostNamespace } from "../interpreter/host.js";
+import { methods } from "../interpreter/native.js";
 import { applyCollectionCallback } from "../interpreter/runner.js";
 import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
-import { get, ownKeys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
-import { Values } from "../values.js";
-export const jsonGlobal = (runner) => new HostNamespace("JSON", {
-    parse: new HostFunction({ name: "JSON.parse", call: (args, node) => parse(runner, args, node) }),
-    stringify: new HostFunction({ name: "JSON.stringify", call: (args, node) => stringify(runner, args, node) }),
-});
+import { Callable, get, keys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
+export const jsonGlobal = (runner) => {
+    const json = new ProgramObject(runner.prototypes.Object);
+    methods(runner.prototypes, json, [
+        ["parse", 2, (_, args, node) => parse(runner, args, node)],
+        ["stringify", 3, (_, args, node) => stringify(runner, args, node)],
+    ]);
+    return json;
+};
 const parse = (runner, args, node) => {
     const text = args[0];
     if (typeof text !== "string")
         throw new InterpreterRuntimeError("JSON.parse expects a string.", node);
     const parsed = (() => {
         try {
-            return fromData(JSON.parse(text), "JSON.parse result");
+            return fromData(runner.prototypes, JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
             throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node);
@@ -28,7 +31,7 @@ const parse = (runner, args, node) => {
     const visit = (holder, key) => Effect.gen(function* () {
         const value = get(holder, key);
         if (value instanceof ProgramObject) {
-            for (const name of ownKeys(value)) {
+            for (const name of keys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
                     remove(value, name);
@@ -38,7 +41,7 @@ const parse = (runner, args, node) => {
         }
         return yield* apply([key, value]);
     });
-    return visit(record({ "": parsed }), "");
+    return visit(record(runner.prototypes.Object, { "": parsed }), "");
 };
 const stringify = (runner, args, node) => {
     const space = args[2];
@@ -53,14 +56,14 @@ const stringify = (runner, args, node) => {
         return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value"), properties, indent));
     }
     // Validate up front; the replacer walk below reads the original value.
-    toProgram(args[0], "JSON.stringify value");
+    toProgram(runner.prototypes, args[0], "JSON.stringify value");
     const apply = applyCollectionCallback(runner, replacer, "JSON.stringify", node);
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = yield* apply([key, toJSONValue(get(holder, key))]);
+        const value = yield* apply([key, yield* toJSONValue(runner, get(holder, key), key, node)]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        toProgram(value, "JSON.stringify replacer result");
+        toProgram(runner.prototypes, value, "JSON.stringify replacer result");
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -79,9 +82,7 @@ const stringify = (runner, args, node) => {
             return result;
         }
         const result = Object.create(null);
-        for (const name of ownKeys(value)) {
-            if (typeof name !== "string")
-                continue;
+        for (const name of keys(value)) {
             const item = yield* visit(value, name);
             if (item !== undefined)
                 result[name] = item;
@@ -89,13 +90,12 @@ const stringify = (runner, args, node) => {
         stack.delete(value);
         return result;
     });
-    return Effect.map(visit(record({ "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
+    return Effect.map(visit(record(runner.prototypes.Object, { "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
 };
-const toJSONValue = (value) => {
-    if (value instanceof Values.Date) {
-        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
-    }
-    if (value instanceof Values.URL)
-        return value.url.href;
-    return value;
+// SerializeJSONProperty step 2: a callable `toJSON` decides the value, as Date and URL define.
+const toJSONValue = (runner, value, key, node) => {
+    if (!(value instanceof ProgramObject))
+        return Effect.succeed(value);
+    const toJSON = get(value, "toJSON");
+    return toJSON instanceof Callable ? runner.invokeCallable(toJSON, value, [key], node) : Effect.succeed(value);
 };

package/dist/stdlib/math.d.ts

@@ -1,8 +1,8 @@
-import { HostNamespace } from "../interpreter/host.js";
+import { ProgramObject } from "../interpreter/objects.js";
 import { type Runner } from "../interpreter/runner.js";
 declare global {
     interface Math {
         sumPrecise(values: Iterable<number>): number;
     }
 }
-export declare const mathGlobal: <R>(runner: Runner<R>) => HostNamespace;
+export declare const mathGlobal: <R>(runner: Runner<R>) => ProgramObject;

package/dist/stdlib/math.js

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
-import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
+import { constants, methods } from "../interpreter/native.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ProgramObject } from "../interpreter/objects.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
 // Validate only the arguments a method consumes; like JS, extras are ignored
 // (so built-ins work as callbacks receiving (element, index, array)).
 const number = (name, args, index, node) => {
@@ -12,78 +13,97 @@ const number = (name, args, index, node) => {
         throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
     return arg;
 };
-const unary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node)));
-const binary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node), number(name, args, 1, node)));
-const variadic = (name, op) => sync(`Math.${name}`, (args, node) => op(...args.map((arg) => {
-    if (typeof arg !== "number")
-        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-    return arg;
-})));
-const sumPrecise = (runner) => new HostFunction({
-    name: "Math.sumPrecise",
-    call: (args, node) => Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(args[0], node);
-        if (cursor === undefined) {
-            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node);
-        }
-        const numbers = [];
-        while (true) {
-            const step = yield* cursor.next;
-            if (step.done)
-                return Math.sumPrecise(numbers);
-            yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (typeof step.value !== "number") {
-                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node);
+const unary = (name, op) => [
+    name,
+    1,
+    (_, args, node) => op(number(name, args, 0, node)),
+];
+const binary = (name, op) => [
+    name,
+    2,
+    (_, args, node) => op(number(name, args, 0, node), number(name, args, 1, node)),
+];
+const variadic = (name, op) => [
+    name,
+    2,
+    (_, args, node) => op(...args.map((arg) => {
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+        return arg;
+    })),
+];
+export const mathGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const math = new ProgramObject(protos.Object);
+    constants(math, {
+        PI: Math.PI,
+        E: Math.E,
+        LN2: Math.LN2,
+        LN10: Math.LN10,
+        LOG2E: Math.LOG2E,
+        LOG10E: Math.LOG10E,
+        SQRT2: Math.SQRT2,
+        SQRT1_2: Math.SQRT1_2,
+    });
+    methods(protos, math, [
+        ["random", 0, () => Math.random()],
+        variadic("max", Math.max),
+        variadic("min", Math.min),
+        variadic("hypot", Math.hypot),
+        unary("abs", Math.abs),
+        unary("acos", Math.acos),
+        unary("acosh", Math.acosh),
+        unary("asin", Math.asin),
+        unary("asinh", Math.asinh),
+        unary("atan", Math.atan),
+        binary("atan2", Math.atan2),
+        unary("atanh", Math.atanh),
+        unary("floor", Math.floor),
+        unary("ceil", Math.ceil),
+        unary("round", Math.round),
+        unary("trunc", Math.trunc),
+        unary("sign", Math.sign),
+        unary("sqrt", Math.sqrt),
+        unary("cbrt", Math.cbrt),
+        binary("pow", Math.pow),
+        unary("cos", Math.cos),
+        unary("cosh", Math.cosh),
+        unary("sin", Math.sin),
+        unary("sinh", Math.sinh),
+        unary("tan", Math.tan),
+        unary("tanh", Math.tanh),
+        unary("log", Math.log),
+        unary("log2", Math.log2),
+        unary("log10", Math.log10),
+        unary("log1p", Math.log1p),
+        unary("exp", Math.exp),
+        unary("expm1", Math.expm1),
+        unary("f16round", Math.f16round),
+        unary("fround", Math.fround),
+        unary("clz32", Math.clz32),
+        binary("imul", Math.imul),
+        [
+            "sumPrecise",
+            1,
+            (_, args, node) => Effect.gen(function* () {
+                const cursor = yield* runner.syncIterator(args[0], node);
+                if (cursor === undefined) {
+                    throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node);
+                }
+                const numbers = [];
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return Math.sumPrecise(numbers);
+                    yield* preserveConsumerError(cursor, Effect.sync(() => {
+                        if (typeof step.value !== "number") {
+                            throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node);
+                        }
+                        numbers.push(step.value);
+                    }));
                 }
-                numbers.push(step.value);
-            }));
-        }
-    }),
-});
-export const mathGlobal = (runner) => new HostNamespace("Math", {
-    PI: Math.PI,
-    E: Math.E,
-    LN2: Math.LN2,
-    LN10: Math.LN10,
-    LOG2E: Math.LOG2E,
-    LOG10E: Math.LOG10E,
-    SQRT2: Math.SQRT2,
-    SQRT1_2: Math.SQRT1_2,
-    random: sync("Math.random", () => Math.random()),
-    max: variadic("max", Math.max),
-    min: variadic("min", Math.min),
-    hypot: variadic("hypot", Math.hypot),
-    abs: unary("abs", Math.abs),
-    acos: unary("acos", Math.acos),
-    acosh: unary("acosh", Math.acosh),
-    asin: unary("asin", Math.asin),
-    asinh: unary("asinh", Math.asinh),
-    atan: unary("atan", Math.atan),
-    atan2: binary("atan2", Math.atan2),
-    atanh: unary("atanh", Math.atanh),
-    floor: unary("floor", Math.floor),
-    ceil: unary("ceil", Math.ceil),
-    round: unary("round", Math.round),
-    trunc: unary("trunc", Math.trunc),
-    sign: unary("sign", Math.sign),
-    sqrt: unary("sqrt", Math.sqrt),
-    cbrt: unary("cbrt", Math.cbrt),
-    pow: binary("pow", Math.pow),
-    cos: unary("cos", Math.cos),
-    cosh: unary("cosh", Math.cosh),
-    sin: unary("sin", Math.sin),
-    sinh: unary("sinh", Math.sinh),
-    tan: unary("tan", Math.tan),
-    tanh: unary("tanh", Math.tanh),
-    log: unary("log", Math.log),
-    log2: unary("log2", Math.log2),
-    log10: unary("log10", Math.log10),
-    log1p: unary("log1p", Math.log1p),
-    exp: unary("exp", Math.exp),
-    expm1: unary("expm1", Math.expm1),
-    f16round: unary("f16round", Math.f16round),
-    fround: unary("fround", Math.fround),
-    clz32: unary("clz32", Math.clz32),
-    imul: binary("imul", Math.imul),
-    sumPrecise: sumPrecise(runner),
-});
+            }),
+        ],
+    ]);
+    return math;
+};

package/dist/stdlib/number.d.ts

@@ -1,4 +1,3 @@
-import { type AstNode } from "../interpreter/model.js";
-export declare const numberMethods: Set<string>;
-export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
-export declare const numberGlobal: import("../interpreter/host.js").HostFunction<never>;
+import type { Runner } from "../interpreter/runner.js";
+export declare const numberGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const booleanGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;