@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/stdlib/date.js

@@ -1,24 +1,36 @@
 import { Effect } from "effect";
-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 { HostFunction, sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { toPrimitive } from "../interpreter/runner.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-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 = [
+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",
     "getFullYear",
     "getMonth",
     "getDate",
@@ -36,78 +48,161 @@ const getters = [
     "getUTCSeconds",
     "getUTCMilliseconds",
     "getTimezoneOffset",
-];
-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;
+    ...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 new InterpreterRuntimeError("Invalid time value.", node).as("RangeError");
+            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;
 };

package/dist/stdlib/json.d.ts

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

package/dist/stdlib/json.js

@@ -1,28 +1,25 @@
 import { Effect } from "effect";
-import { methods } from "../interpreter/native.js";
+import { HostFunction, HostNamespace } from "../interpreter/host.js";
 import { applyCollectionCallback } from "../interpreter/runner.js";
-import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
-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;
-};
+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) }),
+});
 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(runner.prototypes, JSON.parse(text), "JSON.parse result");
+            return fromData(JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
-            throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node);
+            throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
         }
     })();
     if (typeofValue(args[1]) !== "function")
@@ -31,7 +28,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 keys(value)) {
+            for (const name of ownKeys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
                     remove(value, name);
@@ -41,7 +38,7 @@ const parse = (runner, args, node) => {
         }
         return yield* apply([key, value]);
     });
-    return visit(record(runner.prototypes.Object, { "": parsed }), "");
+    return visit(record({ "": parsed }), "");
 };
 const stringify = (runner, args, node) => {
     const space = args[2];
@@ -56,14 +53,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(runner.prototypes, args[0], "JSON.stringify value");
+    toProgram(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, yield* toJSONValue(runner, get(holder, key), key, node)]);
+        const value = yield* apply([key, toJSONValue(get(holder, key))]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        toProgram(runner.prototypes, value, "JSON.stringify replacer result");
+        toProgram(value, "JSON.stringify replacer result");
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -71,7 +68,7 @@ const stringify = (runner, args, node) => {
         if (!(value instanceof ProgramObject))
             return {};
         if (stack.has(value))
-            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node);
+            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
         stack.add(value);
         if (value instanceof ProgramArray) {
             const result = [];
@@ -82,7 +79,9 @@ const stringify = (runner, args, node) => {
             return result;
         }
         const result = Object.create(null);
-        for (const name of keys(value)) {
+        for (const name of ownKeys(value)) {
+            if (typeof name !== "string")
+                continue;
             const item = yield* visit(value, name);
             if (item !== undefined)
                 result[name] = item;
@@ -90,12 +89,13 @@ const stringify = (runner, args, node) => {
         stack.delete(value);
         return result;
     });
-    return Effect.map(visit(record(runner.prototypes.Object, { "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
+    return Effect.map(visit(record({ "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
 };
-// 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);
+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;
 };

package/dist/stdlib/math.d.ts

@@ -1,8 +1,8 @@
-import { ProgramObject } from "../interpreter/objects.js";
+import { HostNamespace } from "../interpreter/host.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>) => ProgramObject;
+export declare const mathGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/math.js

@@ -1,8 +1,7 @@
 import { Effect } from "effect";
-import { constants, methods } from "../interpreter/native.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
+import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
+import { InterpreterRuntimeError } from "../interpreter/model.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) => {
@@ -13,97 +12,78 @@ const number = (name, args, index, node) => {
         throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
     return arg;
 };
-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);
-                    }));
+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).as("TypeError");
+        }
+        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).as("TypeError");
                 }
-            }),
-        ],
-    ]);
-    return math;
-};
+                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),
+});

package/dist/stdlib/number.d.ts

@@ -1,3 +1,4 @@
-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>;
+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>;