@opencode/codemode 2.0.0 → 2.0.2

package/dist/stdlib/collections.js

@@ -1,132 +1,73 @@
 import { Effect } from "effect";
-import { HostFunction, requiresNew } from "../interpreter/host.js";
+import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { getOwn, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
+import { define, defineAccessor, get, getOwn, hidden, isWrapper, ProgramArray, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, } from "../interpreter/objects.js";
 import { describeValue, isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
-import { Values } from "../values.js";
-import { coerceToString } from "./value.js";
-export const arrayMethods = new Set([
-    "map",
-    "filter",
-    "find",
-    "findIndex",
-    "findLast",
-    "findLastIndex",
-    "some",
-    "every",
-    "includes",
-    "join",
-    "reduce",
-    "reduceRight",
-    "flatMap",
-    "forEach",
-    "sort",
-    "toSorted",
-    "slice",
-    "concat",
-    "indexOf",
-    "lastIndexOf",
-    "at",
-    "flat",
-    "reverse",
-    "toReversed",
-    "with",
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "splice",
-    "toSpliced",
-    "fill",
-    "copyWithin",
-    "keys",
-    "values",
-    "entries",
-]);
-export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"]);
-export const setMethods = new Set([
-    "add",
-    "has",
-    "delete",
-    "clear",
-    "forEach",
-    "keys",
-    "values",
-    "entries",
-    "union",
-    "intersection",
-    "difference",
-    "symmetricDifference",
-    "isSubsetOf",
-    "isSupersetOf",
-    "isDisjointFrom",
-]);
+import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/runner.js";
 const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value instanceof Values.Promise)
+    if (value instanceof ProgramPromise)
         return Effect.succeed("[object Promise]");
-    if (!Values.isValue(value) && isRuntimeReference(value)) {
+    if (!isWrapper(value) && isRuntimeReference(value)) {
         throw new InterpreterRuntimeError(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`, node, "InvalidDataValue");
     }
-    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
+    return toPrimitiveString(runner, value, node);
 };
 /** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
-export const groupBy = (runner, namespace) => new HostFunction({
-    name: `${namespace}.groupBy`,
-    call: (args, node) => {
-        const source = args[0];
-        if (source === null || source === undefined) {
-            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
-        }
-        const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
-        return Effect.gen(function* () {
-            const cursor = yield* runner.syncIterator(source, node);
-            if (cursor === undefined) {
-                throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
-            }
-            if (namespace === "Map") {
-                const result = new Values.Map();
-                let index = 0;
-                while (true) {
-                    const step = yield* cursor.next;
-                    if (step.done)
-                        return result;
-                    const item = step.value;
-                    const key = yield* preserveConsumerError(cursor, apply([item, index]));
-                    const group = result.map.get(key);
-                    if (group === undefined)
-                        result.map.set(key, new ProgramArray([item]));
-                    else
-                        group.items.push(item);
-                    index += 1;
-                }
-            }
-            const result = new ProgramObject();
+export const groupBy = (runner, namespace) => fn(runner.prototypes, "groupBy", 2, (_, args, node) => {
+    const protos = runner.prototypes;
+    const source = args[0];
+    if (source === null || source === undefined) {
+        throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
+    }
+    const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
+        }
+        if (namespace === "Map") {
+            const result = new ProgramMap(protos.Map);
             let index = 0;
             while (true) {
                 const step = yield* cursor.next;
                 if (step.done)
                     return result;
                 const item = step.value;
-                const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
-                const group = getOwn(result, key);
+                const key = yield* preserveConsumerError(cursor, apply([item, index]));
+                const group = result.map.get(key);
                 if (group === undefined)
-                    set(result, key, new ProgramArray([item]));
+                    result.map.set(key, new ProgramArray(protos.Array, [item]));
                 else
                     group.items.push(item);
                 index += 1;
             }
-        });
-    },
+        }
+        // Object.groupBy returns a null-prototype object, so group names never collide with inherited methods.
+        const result = new ProgramObject(null);
+        let index = 0;
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return result;
+            const item = step.value;
+            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+            const group = getOwn(result, key);
+            if (group === undefined)
+                define(result, key, new ProgramArray(protos.Array, [item]));
+            else
+                group.items.push(item);
+            index += 1;
+        }
+    });
 });
-const constructMap = (runner, init, node) => {
-    const target = new Values.Map();
+const constructMap = (runner, init, proto, node) => {
+    const target = new ProgramMap(proto);
     if (init === undefined || init === null)
         return Effect.succeed(target);
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(init, node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -134,21 +75,21 @@ const constructMap = (runner, init, node) => {
                 return target;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (!(step.value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node);
                 }
                 target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
             }));
         }
     });
 };
-const constructSet = (runner, init, node) => {
-    const target = new Values.Set();
+const constructSet = (runner, init, proto, node) => {
+    const target = new ProgramSet(proto);
     if (init === undefined || init === null)
         return Effect.succeed(target);
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(init, node);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -158,16 +99,247 @@ const constructSet = (runner, init, node) => {
         }
     });
 };
-export const mapGlobal = (runner) => new HostFunction({
-    name: "Map",
-    call: requiresNew("Map"),
-    construct: (args, node) => constructMap(runner, args[0], node),
-    instanceOf: (value) => value instanceof Values.Map,
-    members: { groupBy: groupBy(runner, "Map") },
-});
-export const setGlobal = (runner) => new HostFunction({
-    name: "Set",
-    call: requiresNew("Set"),
-    construct: (args, node) => constructSet(runner, args[0], node),
-    instanceOf: (value) => value instanceof Values.Set,
+export const mapGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const proto = protos.Map;
+    const map = constructor(protos, proto, {
+        name: "Map",
+        call: requiresNew("Map"),
+        construct: (args, newTarget, node) => constructMap(runner, args[0], prototypeFrom(newTarget, proto), node),
+    });
+    define(map, "groupBy", groupBy(runner, "Map"), hidden);
+    const self = (thisValue, name, node) => receiver(ProgramMap, thisValue, `Map.prototype.${name}`, node);
+    const wrap = (items) => new ProgramArray(protos.Array, items);
+    defineAccessor(proto, "size", (thisValue) => receiver(ProgramMap, thisValue, "Map.prototype.size").map.size);
+    methods(protos, proto, [
+        ["get", 1, (thisValue, args, node) => self(thisValue, "get", node).map.get(args[0])],
+        ["has", 1, (thisValue, args, node) => self(thisValue, "has", node).map.has(args[0])],
+        [
+            "set",
+            2,
+            (thisValue, args, node) => {
+                const target = self(thisValue, "set", node);
+                target.map.set(args[0], args[1]);
+                return target;
+            },
+        ],
+        ["delete", 1, (thisValue, args, node) => self(thisValue, "delete", node).map.delete(args[0])],
+        [
+            "clear",
+            0,
+            (thisValue, _, node) => {
+                self(thisValue, "clear", node).map.clear();
+                return undefined;
+            },
+        ],
+        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).map.keys()))],
+        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).map.values()))],
+        [
+            "entries",
+            0,
+            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).map.entries(), ([key, item]) => wrap([key, item]))),
+        ],
+        [
+            "forEach",
+            1,
+            (thisValue, args, node) => {
+                const target = self(thisValue, "forEach", node);
+                const apply = applyCollectionCallback(runner, args[0], "Map.forEach", node);
+                return Effect.gen(function* () {
+                    for (const [key, item] of Array.from(target.map.entries()))
+                        yield* apply([item, key, target]);
+                    return undefined;
+                });
+            },
+        ],
+    ]);
+    return map;
+};
+const loadSetRecord = (runner, source, name, node) => {
+    if (source instanceof ProgramSet) {
+        return Effect.succeed({
+            size: source.set.size,
+            has: (item) => Effect.succeed(source.set.has(item)),
+            keys: () => Effect.succeed(source.set.values()),
+        });
+    }
+    if (source instanceof ProgramMap) {
+        return Effect.succeed({
+            size: source.map.size,
+            has: (item) => Effect.succeed(source.map.has(item)),
+            keys: () => Effect.succeed(source.map.keys()),
+        });
+    }
+    if (!(source instanceof ProgramObject)) {
+        throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node);
+    }
+    return Effect.gen(function* () {
+        const size = yield* toPrimitiveNumber(runner, get(source, "size"), node);
+        if (Number.isNaN(size)) {
+            throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node);
+        }
+        const has = get(source, "has");
+        const keys = get(source, "keys");
+        if (!isSupportedCallback(has) || !isSupportedCallback(keys)) {
+            throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node);
+        }
+        return {
+            size: Math.max(Math.trunc(size), 0),
+            has: (item) => Effect.map(runner.invokeCallable(has, source, [item], node), Boolean),
+            keys: () => Effect.flatMap(runner.invokeCallable(keys, source, [], node), (result) => {
+                if (result instanceof ProgramArray)
+                    return Effect.succeed(result.items);
+                throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node);
+            }),
+        };
+    });
+};
+const setOperation = (runner, target, name, source, node) => Effect.gen(function* () {
+    const other = yield* loadSetRecord(runner, source, name, node);
+    const copy = () => {
+        const result = new ProgramSet(runner.prototypes.Set);
+        for (const item of target.set.values())
+            result.set.add(item);
+        return result;
+    };
+    if (name === "union") {
+        const result = copy();
+        for (const item of yield* other.keys())
+            result.set.add(item);
+        return result;
+    }
+    if (name === "intersection") {
+        const result = new ProgramSet(runner.prototypes.Set);
+        if (target.set.size <= other.size) {
+            for (const item of target.set.values()) {
+                if (yield* other.has(item))
+                    result.set.add(item);
+            }
+            return result;
+        }
+        for (const item of yield* other.keys()) {
+            if (target.set.has(item))
+                result.set.add(item);
+        }
+        return result;
+    }
+    if (name === "difference") {
+        const result = copy();
+        if (target.set.size <= other.size) {
+            for (const item of result.set.values()) {
+                if (yield* other.has(item))
+                    result.set.delete(item);
+            }
+            return result;
+        }
+        for (const item of yield* other.keys())
+            result.set.delete(item);
+        return result;
+    }
+    if (name === "symmetricDifference") {
+        const result = copy();
+        for (const item of yield* other.keys()) {
+            if (target.set.has(item))
+                result.set.delete(item);
+            else
+                result.set.add(item);
+        }
+        return result;
+    }
+    if (name === "isSubsetOf") {
+        if (target.set.size > other.size)
+            return false;
+        for (const item of target.set.values()) {
+            if (!(yield* other.has(item)))
+                return false;
+        }
+        return true;
+    }
+    if (name === "isSupersetOf") {
+        if (target.set.size < other.size)
+            return false;
+        for (const item of yield* other.keys()) {
+            if (!target.set.has(item))
+                return false;
+        }
+        return true;
+    }
+    if (target.set.size <= other.size) {
+        for (const item of target.set.values()) {
+            if (yield* other.has(item))
+                return false;
+        }
+        return true;
+    }
+    for (const item of yield* other.keys()) {
+        if (target.set.has(item))
+            return false;
+    }
+    return true;
 });
+export const setGlobal = (runner) => {
+    const protos = runner.prototypes;
+    const proto = protos.Set;
+    const set = constructor(protos, proto, {
+        name: "Set",
+        call: requiresNew("Set"),
+        construct: (args, newTarget, node) => constructSet(runner, args[0], prototypeFrom(newTarget, proto), node),
+    });
+    const self = (thisValue, name, node) => receiver(ProgramSet, thisValue, `Set.prototype.${name}`, node);
+    const wrap = (items) => new ProgramArray(protos.Array, items);
+    const operation = (name) => [
+        name,
+        1,
+        (thisValue, args, node) => setOperation(runner, self(thisValue, name, node), name, args[0], node),
+    ];
+    defineAccessor(proto, "size", (thisValue) => receiver(ProgramSet, thisValue, "Set.prototype.size").set.size);
+    methods(protos, proto, [
+        ["has", 1, (thisValue, args, node) => self(thisValue, "has", node).set.has(args[0])],
+        [
+            "add",
+            1,
+            (thisValue, args, node) => {
+                const target = self(thisValue, "add", node);
+                target.set.add(args[0]);
+                return target;
+            },
+        ],
+        ["delete", 1, (thisValue, args, node) => self(thisValue, "delete", node).set.delete(args[0])],
+        [
+            "clear",
+            0,
+            (thisValue, _, node) => {
+                self(thisValue, "clear", node).set.clear();
+                return undefined;
+            },
+        ],
+        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).set.values()))],
+        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).set.values()))],
+        [
+            "entries",
+            0,
+            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).set.values(), (item) => wrap([item, item]))),
+        ],
+        [
+            "forEach",
+            1,
+            (thisValue, args, node) => {
+                const target = self(thisValue, "forEach", node);
+                const apply = applyCollectionCallback(runner, args[0], "Set.forEach", node);
+                return Effect.gen(function* () {
+                    for (const item of Array.from(target.set.values()))
+                        yield* apply([item, item, target]);
+                    return undefined;
+                });
+            },
+        ],
+        operation("union"),
+        operation("intersection"),
+        operation("difference"),
+        operation("symmetricDifference"),
+        operation("isSubsetOf"),
+        operation("isSupersetOf"),
+        operation("isDisjointFrom"),
+    ]);
+    return set;
+};

package/dist/stdlib/console.d.ts

@@ -1,3 +1,4 @@
-import { HostNamespace } from "../interpreter/host.js";
+import { ProgramObject } from "../interpreter/objects.js";
+import type { Runner } from "../interpreter/runner.js";
 /** Captured console: every method appends one formatted line to `logs`. */
-export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;
+export declare const consoleGlobal: <R>(runner: Runner<R>, logs: Array<string>) => ProgramObject;

package/dist/stdlib/console.js

@@ -1,24 +1,29 @@
 import { toData, toProgram } from "../data.js";
-import { HostNamespace, sync } from "../interpreter/host.js";
-import { get, ownEntries, ProgramArray, ProgramObject } from "../interpreter/objects.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 { Values } from "../values.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 = (logs) => new HostNamespace("console", Object.fromEntries(consoleMethods.map((name) => [
-    name,
-    sync(`console.${name}`, (args) => {
-        logs.push(formatConsoleMessage(name, args));
-        return undefined;
-    }),
-])));
+export const consoleGlobal = (runner, logs) => {
+    const protos = runner.prototypes;
+    const console = new ProgramObject(protos.Object);
+    methods(protos, console, consoleMethods.map((name) => [
+        name,
+        0,
+        (_, args) => {
+            logs.push(formatConsoleMessage(protos, name, args));
+            return undefined;
+        },
+    ]));
+    return console;
+};
 const MAX_CONSOLE_DEPTH = 32;
-const formatConsoleMessage = (name, args) => {
+const formatConsoleMessage = (protos, name, args) => {
     if (name === "dir")
         return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
     if (name === "table")
-        return formatConsoleTable(args[0], args[1]);
+        return formatConsoleTable(protos, args[0], args[1]);
     const prefix = name === "warn" ? "[warn] " : name === "error" ? "[error] " : name === "debug" ? "[debug] " : "";
     return `${prefix}${args.map((arg) => formatConsoleArgument(arg)).join(" ")}`;
 };
@@ -38,34 +43,34 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof Values.Promise)
+    if (value instanceof ProgramPromise)
         return "[Promise (await it to get its value)]";
-    if (value instanceof Values.Date)
+    if (value instanceof ProgramDate)
         return coerceToString(value);
-    if (value instanceof Values.RegExp)
+    if (value instanceof ProgramRegExp)
         return coerceToString(value);
-    if (value instanceof Values.URL)
+    if (value instanceof ProgramURL)
         return coerceToString(value);
-    if (value instanceof Values.URLSearchParams)
+    if (value instanceof ProgramURLSearchParams)
         return coerceToString(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof Values.Map) {
+    if (value instanceof ProgramMap) {
         seen.add(value);
         try {
-            const entries = Array.from(value.map.entries(), ([key, item]) => new ProgramArray([key, item]));
-            return `Map(${value.map.size}) ${formatConsoleValue(new ProgramArray(entries), seen, depth + 1)}`;
+            const items = Array.from(value.map.entries(), ([key, item]) => `[${formatItems([key, item], seen, depth + 1)}]`);
+            return `Map(${value.map.size}) [${items.join(",")}]`;
         }
         finally {
             seen.delete(value);
         }
     }
-    if (value instanceof Values.Set) {
+    if (value instanceof ProgramSet) {
         seen.add(value);
         try {
-            return `Set(${value.set.size}) ${formatConsoleValue(new ProgramArray([...value.set.values()]), seen, depth + 1)}`;
+            return `Set(${value.set.size}) [${formatItems([...value.set.values()], seen, depth + 1)}]`;
         }
         finally {
             seen.delete(value);
@@ -75,12 +80,11 @@ const formatConsoleValue = (value, seen, depth) => {
         return "[opaque reference]";
     seen.add(value);
     try {
-        if (value instanceof ProgramArray) {
-            return `[${value.items.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
-        }
+        if (value instanceof ProgramArray)
+            return `[${formatItems(value.items, seen, depth + 1)}]`;
         if (!(value instanceof ProgramObject))
             return "[object Object]";
-        return `{${ownEntries(value)
+        return `{${entries(value)
             .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
             .join(",")}}`;
     }
@@ -88,12 +92,13 @@ const formatConsoleValue = (value, seen, depth) => {
         seen.delete(value);
     }
 };
-const formatConsoleTable = (value, columnsArgument) => {
+const formatItems = (items, seen, depth) => items.map((item) => formatConsoleValue(item, seen, depth)).join(",");
+const formatConsoleTable = (protos, value, columnsArgument) => {
     if (value === undefined)
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = toProgram(value, "console.table argument");
+    const data = toProgram(protos, value, "console.table argument");
     const columns = consoleTableColumns(columnsArgument);
     const rows = consoleTableRows(data, columns);
     const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
@@ -116,7 +121,7 @@ const consoleTableRows = (data, columns) => {
         return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
     if (data instanceof ProgramObject) {
-        return ownEntries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
+        return entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
@@ -124,7 +129,7 @@ const consoleTableValues = (value, columns) => {
     if (value instanceof ProgramObject && !(value instanceof ProgramArray)) {
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
-        return Object.fromEntries(ownEntries(value));
+        return Object.fromEntries(entries(value));
     }
     return { Value: value };
 };

package/dist/stdlib/date.d.ts

@@ -1,8 +1,2 @@
-import { HostFunction } from "../interpreter/host.js";
-import { type AstNode } from "../interpreter/model.js";
 import { type Runner } from "../interpreter/runner.js";
-import { Values } from "../values.js";
-export declare const dateMethods: Set<string>;
-export declare const dateGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
-export declare const dateSetterArgumentCount: (name: string) => number | undefined;
-export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;
+export declare const dateGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;