@opencode/codemode 2.0.3 → 2.0.4

package/dist/stdlib/console.js

@@ -1,33 +1,33 @@
-import { toData, toProgram } from "../data.js";
 import { methods } from "../interpreter/native.js";
-import { entries, get, ProgramArray, ProgramDate, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
-import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
+import { entries, get, Arr, Bytes, DateObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
+import { containsOpaqueReference, isRuntimeReference } from "../interpreter/references.js";
 import { coerceToString } from "./value.js";
 const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
 /** Captured console: every method appends one formatted line to `logs`. */
-export const consoleGlobal = (runner, logs) => {
-    const protos = runner.prototypes;
-    const console = new ProgramObject(protos.Object);
-    methods(protos, console, consoleMethods.map((name) => [
+export const consoleGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const console = new Obj(builtins.Object);
+    methods(builtins, console, consoleMethods.map((name) => [
         name,
         0,
         (_, args) => {
-            logs.push(formatConsoleMessage(protos, name, args));
+            ctx.logs.push(formatConsoleMessage(name, args));
             return undefined;
         },
     ]));
     return console;
 };
 const MAX_CONSOLE_DEPTH = 32;
-const formatConsoleMessage = (protos, name, args) => {
+const formatConsoleMessage = (name, args) => {
     if (name === "dir")
-        return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
+        return args.length === 0 ? "undefined" : formatValue(args[0]);
     if (name === "table")
-        return formatConsoleTable(protos, args[0], args[1]);
+        return formatConsoleTable(args[0], args[1]);
     const prefix = name === "warn" ? "[warn] " : name === "error" ? "[error] " : name === "debug" ? "[debug] " : "";
-    return `${prefix}${args.map((arg) => formatConsoleArgument(arg)).join(" ")}`;
+    return `${prefix}${args.map((arg) => formatValue(arg)).join(" ")}`;
 };
-const formatConsoleArgument = (value) => {
+/** One value as `console.log` shows it. */
+export const formatValue = (value) => {
     if (value === undefined)
         return "undefined";
     if (typeof value === "string")
@@ -43,21 +43,23 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof ProgramPromise)
+    if (value instanceof PromiseObj)
         return "[Promise (await it to get its value)]";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return coerceToString(value);
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return coerceToString(value);
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return coerceToString(value);
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return coerceToString(value);
+    if (value instanceof Bytes)
+        return `Uint8Array(${value.bytes.length}) [${value.bytes.join(",")}]`;
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof ProgramMap) {
+    if (value instanceof MapObj) {
         seen.add(value);
         try {
             const items = Array.from(value.map.entries(), ([key, item]) => `[${formatItems([key, item], seen, depth + 1)}]`);
@@ -67,7 +69,7 @@ const formatConsoleValue = (value, seen, depth) => {
             seen.delete(value);
         }
     }
-    if (value instanceof ProgramSet) {
+    if (value instanceof SetObj) {
         seen.add(value);
         try {
             return `Set(${value.set.size}) [${formatItems([...value.set.values()], seen, depth + 1)}]`;
@@ -80,9 +82,9 @@ const formatConsoleValue = (value, seen, depth) => {
         return "[opaque reference]";
     seen.add(value);
     try {
-        if (value instanceof ProgramArray)
+        if (value instanceof Arr)
             return `[${formatItems(value.items, seen, depth + 1)}]`;
-        if (!(value instanceof ProgramObject))
+        if (!(value instanceof Obj))
             return "[object Object]";
         return `{${entries(value)
             .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
@@ -93,14 +95,13 @@ const formatConsoleValue = (value, seen, depth) => {
     }
 };
 const formatItems = (items, seen, depth) => items.map((item) => formatConsoleValue(item, seen, depth)).join(",");
-const formatConsoleTable = (protos, value, columnsArgument) => {
+const formatConsoleTable = (value, columnsArgument) => {
     if (value === undefined)
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = toProgram(protos, value, "console.table argument");
-    const columns = consoleTableColumns(columnsArgument);
-    const rows = consoleTableRows(data, columns);
+    const columns = columnsArgument instanceof Arr ? columnsArgument.items.map(String) : undefined;
+    const rows = consoleTableRows(value, columns);
     const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
     const header = ["(index)", ...keys].join("\t");
     return [
@@ -108,25 +109,17 @@ const formatConsoleTable = (protos, value, columnsArgument) => {
         ...rows.map((row) => [row.index, ...keys.map((key) => formatConsoleTableCell(row.values[key]))].join("\t")),
     ].join("\n");
 };
-const consoleTableColumns = (value) => {
-    if (value === undefined)
-        return undefined;
-    if (containsRuntimeReference(value))
-        return undefined;
-    const columns = toData(value, "console.table columns", "result");
-    return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
-};
 const consoleTableRows = (data, columns) => {
-    if (data instanceof ProgramArray) {
+    if (data instanceof Arr) {
         return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data instanceof ProgramObject) {
+    if (data instanceof Obj) {
         return entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value instanceof ProgramObject && !(value instanceof ProgramArray)) {
+    if (value instanceof Obj && !(value instanceof Arr)) {
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
         return Object.fromEntries(entries(value));

package/dist/stdlib/date.d.ts

@@ -1,2 +1,2 @@
-import { type Runner } from "../interpreter/runner.js";
-export declare const dateGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const dateGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/date.js

@@ -1,22 +1,22 @@
 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 { DateObj, Obj } from "../interpreter/objects.js";
+import { toPrimitive, toPrimitiveNumber } from "../interpreter/callback.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const constructDate = (runner, args, proto, node) => {
+const constructDate = (ctx, args, proto) => {
     if (args.length === 0)
-        return Effect.succeed(new ProgramDate(proto, Date.now()));
+        return Effect.succeed(new DateObj(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()));
+        if (arg instanceof DateObj)
+            return Effect.succeed(new DateObj(proto, arg.time));
+        return Effect.map(toPrimitive(ctx, arg, "default"), (value) => typeof value === "string"
+            ? new DateObj(proto, Date.parse(value))
+            : new DateObj(proto, new Date(coerceToNumber(value)).getTime()));
     }
     const parts = args.map((arg) => coerceToNumber(arg));
-    return Effect.succeed(new ProgramDate(proto, new Date(...parts).getTime()));
+    return Effect.succeed(new DateObj(proto, new Date(...parts).getTime()));
 };
 const getters = [
     "getFullYear",
@@ -54,53 +54,53 @@ const setters = [
     ["setFullYear", 3],
     ["setUTCFullYear", 3],
 ];
-export const dateGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Date;
-    const date = constructor(protos, proto, {
+export const dateGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Date;
+    const date = constructor(builtins, 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),
+        construct: (args, newTarget) => constructDate(ctx, args, prototypeFrom(newTarget, proto)),
     });
-    methods(protos, date, [
+    methods(builtins, 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) => {
+    const self = (thisValue, name) => receiver(DateObj, thisValue, `Date.prototype.${name}`);
+    const iso = (value) => {
         if (!Number.isFinite(value.time))
-            throw rangeError("Invalid time value.", node);
+            throw rangeError("Invalid time value.");
         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)],
+    methods(builtins, proto, [
+        ["getTime", 0, (thisValue) => self(thisValue, "getTime").time],
+        ["valueOf", 0, (thisValue) => self(thisValue, "valueOf").time],
+        ["toISOString", 0, (thisValue) => iso(self(thisValue, "toISOString"))],
         [
             "toJSON",
             1,
-            (thisValue, _, node) => {
-                const value = self(thisValue, "toJSON", node);
-                return Number.isFinite(value.time) ? iso(value, node) : null;
+            (thisValue) => {
+                const value = self(thisValue, "toJSON");
+                return Number.isFinite(value.time) ? iso(value) : 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]()]),
+        ["toString", 0, (thisValue) => coerceToString(self(thisValue, "toString"))],
+        ["toDateString", 0, (thisValue) => new Date(self(thisValue, "toDateString").time).toDateString()],
+        ["toTimeString", 0, (thisValue) => new Date(self(thisValue, "toTimeString").time).toTimeString()],
+        ["toUTCString", 0, (thisValue) => new Date(self(thisValue, "toUTCString").time).toUTCString()],
+        ["toGMTString", 0, (thisValue) => new Date(self(thisValue, "toGMTString").time).toUTCString()],
+        ...getters.map((name) => [name, 0, (thisValue) => new Date(self(thisValue, name).time)[name]()]),
         ...setters.map(([name, length]) => [
             name,
             length,
-            (thisValue, args, node) => {
-                const target = self(thisValue, name, node);
+            (thisValue, args) => {
+                const target = self(thisValue, name);
                 // 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), {
+                return Effect.map(Effect.forEach(args.slice(0, length), (arg) => toPrimitiveNumber(ctx, arg), {
                     concurrency: 1,
                 }), (values) => {
                     target.time = hosted[name](...values);

package/dist/stdlib/json.d.ts

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

package/dist/stdlib/json.js

@@ -1,36 +1,37 @@
 import { Effect } from "effect";
 import { methods } from "../interpreter/native.js";
-import { applyCollectionCallback } from "../interpreter/runner.js";
-import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
+import { applyCollectionCallback } from "../interpreter/callback.js";
+import { checkStringLength } from "../interpreter/limits.js";
+import { syntaxError, typeError } 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)],
+import { fromJson, toJson } from "../data.js";
+import { get, keys, Arr, Obj, record, remove, set } from "../interpreter/objects.js";
+export const jsonGlobal = (ctx) => {
+    const json = new Obj(ctx.builtins.Object);
+    methods(ctx.builtins, json, [
+        ["parse", 2, (_, args) => parse(ctx, args)],
+        ["stringify", 3, (_, args) => stringify(ctx, args)],
     ]);
     return json;
 };
-const parse = (runner, args, node) => {
+const parse = (ctx, args) => {
     const text = args[0];
     if (typeof text !== "string")
-        throw new InterpreterRuntimeError("JSON.parse expects a string.", node);
+        throw typeError("JSON.parse expects a string.");
     const parsed = (() => {
         try {
-            return fromData(runner.prototypes, JSON.parse(text), "JSON.parse result");
+            return fromJson(ctx, JSON.parse(text));
         }
         catch (error) {
-            throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node);
+            throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
         }
     })();
     if (typeofValue(args[1]) !== "function")
         return Effect.succeed(parsed);
-    const apply = applyCollectionCallback(runner, args[1], "JSON.parse", node);
+    const apply = applyCollectionCallback(ctx, args[1], "JSON.parse");
     const visit = (holder, key) => Effect.gen(function* () {
         const value = get(holder, key);
-        if (value instanceof ProgramObject) {
+        if (value instanceof Obj) {
             for (const name of keys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
@@ -41,61 +42,22 @@ const parse = (runner, args, node) => {
         }
         return yield* apply([key, value]);
     });
-    return visit(record(runner.prototypes.Object, { "": parsed }), "");
+    return visit(record(ctx.builtins.Object, { "": parsed }), "");
 };
-const stringify = (runner, args, node) => {
+const stringify = (ctx, args) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
-    if (typeofValue(replacer) !== "function") {
-        const properties = replacer instanceof ProgramArray
-            ? replacer.items
-                .filter((item) => typeof item === "string" || typeof item === "number")
-                .map(String)
-            : null;
-        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");
-    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)]);
-        if (value === undefined || typeofValue(value) === "function")
-            return undefined;
-        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")
-            return value;
-        if (!(value instanceof ProgramObject))
-            return {};
-        if (stack.has(value))
-            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node);
-        stack.add(value);
-        if (value instanceof ProgramArray) {
-            const result = [];
-            for (let index = 0; index < value.items.length; index += 1) {
-                result.push((yield* visit(value, String(index))) ?? null);
-            }
-            stack.delete(value);
-            return result;
-        }
-        const result = Object.create(null);
-        for (const name of keys(value)) {
-            const item = yield* visit(value, name);
-            if (item !== undefined)
-                result[name] = item;
-        }
-        stack.delete(value);
-        return result;
+    const properties = replacer instanceof Arr
+        ? replacer.items
+            .filter((item) => typeof item === "string" || typeof item === "number")
+            .map(String)
+        : null;
+    const callback = typeofValue(replacer) === "function" ? applyCollectionCallback(ctx, replacer, "JSON.stringify") : undefined;
+    return Effect.map(toJson(ctx, args[0], callback), (value) => {
+        const text = JSON.stringify(value, properties, indent);
+        if (text !== undefined)
+            checkStringLength(text.length);
+        return text;
     });
-    return Effect.map(visit(record(runner.prototypes.Object, { "": 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);
 };

package/dist/stdlib/math.d.ts

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

package/dist/stdlib/math.js

@@ -1,40 +1,36 @@
 import { Effect } from "effect";
 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";
+import { typeError } from "../interpreter/model.js";
+import { Obj } from "../interpreter/objects.js";
+import { preserveConsumerError } from "../interpreter/callback.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) => {
+const number = (name, args, index) => {
     if (index >= args.length)
         return Number.NaN;
     const arg = args[index];
     if (typeof arg !== "number")
-        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+        throw typeError(`Math.${name} expects number arguments.`);
     return arg;
 };
-const unary = (name, op) => [
-    name,
-    1,
-    (_, args, node) => op(number(name, args, 0, node)),
-];
+const unary = (name, op) => [name, 1, (_, args) => op(number(name, args, 0))];
 const binary = (name, op) => [
     name,
     2,
-    (_, args, node) => op(number(name, args, 0, node), number(name, args, 1, node)),
+    (_, args) => op(number(name, args, 0), number(name, args, 1)),
 ];
 const variadic = (name, op) => [
     name,
     2,
-    (_, args, node) => op(...args.map((arg) => {
+    (_, args) => op(...args.map((arg) => {
         if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+            throw typeError(`Math.${name} expects number arguments.`);
         return arg;
     })),
 ];
-export const mathGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const math = new ProgramObject(protos.Object);
+export const mathGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const math = new Obj(builtins.Object);
     constants(math, {
         PI: Math.PI,
         E: Math.E,
@@ -45,7 +41,7 @@ export const mathGlobal = (runner) => {
         SQRT2: Math.SQRT2,
         SQRT1_2: Math.SQRT1_2,
     });
-    methods(protos, math, [
+    methods(builtins, math, [
         ["random", 0, () => Math.random()],
         variadic("max", Math.max),
         variadic("min", Math.min),
@@ -85,10 +81,10 @@ export const mathGlobal = (runner) => {
         [
             "sumPrecise",
             1,
-            (_, args, node) => Effect.gen(function* () {
-                const cursor = yield* runner.syncIterator(args[0], node);
+            (_, args) => Effect.gen(function* () {
+                const cursor = yield* ctx.iterate(args[0]);
                 if (cursor === undefined) {
-                    throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node);
+                    throw typeError("Math.sumPrecise expects a synchronous iterable.");
                 }
                 const numbers = [];
                 while (true) {
@@ -97,7 +93,7 @@ export const mathGlobal = (runner) => {
                         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);
+                            throw typeError("Math.sumPrecise expects an iterable of numbers.");
                         }
                         numbers.push(step.value);
                     }));

package/dist/stdlib/number.d.ts

@@ -1,3 +1,3 @@
-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 { Interpreter } from "../interpreter/interpreter.js";
+export declare const numberGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const booleanGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/number.js

@@ -1,12 +1,12 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
-import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
+import { rangeError, typeError } from "../interpreter/model.js";
 import { coercion, coerceToString } from "./value.js";
-export const numberGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const number = constructor(protos, protos.Number, {
+export const numberGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const number = constructor(builtins, builtins.Number, {
         name: "Number",
         length: 1,
-        call: coercion(runner, "Number").call,
+        call: coercion(ctx, "Number").call,
     });
     constants(number, {
         MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
@@ -18,7 +18,7 @@ export const numberGlobal = (runner) => {
         POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
         NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
     });
-    methods(protos, number, [
+    methods(builtins, number, [
         ["isInteger", 1, (_, args) => Number.isInteger(args[0])],
         ["isFinite", 1, (_, args) => Number.isFinite(args[0])],
         ["isNaN", 1, (_, args) => Number.isNaN(args[0])],
@@ -26,79 +26,75 @@ export const numberGlobal = (runner) => {
         [
             "parseInt",
             2,
-            (_, args, node) => {
+            (_, args) => {
                 const radix = args[1];
                 if (radix !== undefined && typeof radix !== "number") {
-                    throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
+                    throw typeError("Number.parseInt expects a numeric radix.");
                 }
                 return parseInt(coerceToString(args[0]), radix);
             },
         ],
         ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
     ]);
-    const self = (thisValue, name, node) => {
+    const self = (thisValue, name) => {
         if (typeof thisValue === "number")
             return thisValue;
-        throw new InterpreterRuntimeError(`Number.prototype.${name} requires that 'this' be a Number.`, node);
+        throw typeError(`Number.prototype.${name} requires that 'this' be a Number.`);
     };
-    const optNum = (name, arg, node) => {
+    const optNum = (name, arg) => {
         if (arg === undefined)
             return undefined;
         if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node);
+            throw typeError(`Number.${name} expects a number argument.`);
         return arg;
     };
-    methods(protos, protos.Number, [
-        [
-            "toFixed",
-            1,
-            (thisValue, args, node) => self(thisValue, "toFixed", node).toFixed(optNum("toFixed", args[0], node)),
-        ],
+    methods(builtins, builtins.Number, [
+        ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
         [
             "toExponential",
             1,
-            (thisValue, args, node) => self(thisValue, "toExponential", node).toExponential(optNum("toExponential", args[0], node)),
+            (thisValue, args) => self(thisValue, "toExponential").toExponential(optNum("toExponential", args[0])),
         ],
         [
             "toPrecision",
             1,
-            (thisValue, args, node) => {
-                const value = self(thisValue, "toPrecision", node);
-                const digits = optNum("toPrecision", args[0], node);
+            (thisValue, args) => {
+                const value = self(thisValue, "toPrecision");
+                const digits = optNum("toPrecision", args[0]);
                 return digits === undefined ? value.toString() : value.toPrecision(digits);
             },
         ],
         [
             "toString",
             1,
-            (thisValue, args, node) => {
-                const value = self(thisValue, "toString", node);
-                const radix = optNum("toString", args[0], node);
+            (thisValue, args) => {
+                const value = self(thisValue, "toString");
+                const radix = optNum("toString", args[0]);
                 if (radix !== undefined && (radix < 2 || radix > 36)) {
-                    throw rangeError("Number.toString radix must be between 2 and 36.", node);
+                    throw rangeError("Number.toString radix must be between 2 and 36.");
                 }
                 return value.toString(radix);
             },
         ],
-        ["valueOf", 0, (thisValue, _, node) => self(thisValue, "valueOf", node)],
+        ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
     ]);
     return number;
 };
-export const booleanGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const boolean = constructor(protos, protos.Boolean, {
+export const booleanGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const boolean = constructor(builtins, builtins.Boolean, {
         name: "Boolean",
         length: 1,
-        call: coercion(runner, "Boolean").call,
+        call: coercion(ctx, "Boolean").call,
     });
-    const self = (thisValue, name, node) => {
+    const self = (thisValue, name) => {
         if (typeof thisValue === "boolean")
             return thisValue;
-        throw new InterpreterRuntimeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`, node);
+        throw typeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`);
     };
-    methods(protos, protos.Boolean, [
-        ["toString", 0, (thisValue, _, node) => String(self(thisValue, "toString", node))],
-        ["valueOf", 0, (thisValue, _, node) => self(thisValue, "valueOf", node)],
+    methods(builtins, builtins.Boolean, [
+        ["toString", 0, (thisValue) => String(self(thisValue, "toString"))],
+        ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
     ]);
     return boolean;
 };