@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/stdlib/collections.js

@@ -1,73 +1,132 @@
 import { Effect } from "effect";
-import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
+import { HostFunction, requiresNew } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, isWrapper, ProgramArray, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, } from "../interpreter/objects.js";
+import { getOwn, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
 import { describeValue, isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/runner.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",
+]);
 const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value instanceof ProgramPromise)
+    if (value instanceof Values.Promise)
         return Effect.succeed("[object Promise]");
-    if (!isWrapper(value) && isRuntimeReference(value)) {
+    if (!Values.isValue(value) && isRuntimeReference(value)) {
         throw new InterpreterRuntimeError(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`, node, "InvalidDataValue");
     }
-    return toPrimitiveString(runner, value, node);
+    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
 };
 /** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
-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);
+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();
             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);
+                const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+                const group = getOwn(result, key);
                 if (group === undefined)
-                    result.map.set(key, new ProgramArray(protos.Array, [item]));
+                    set(result, key, new ProgramArray([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, proto, node) => {
-    const target = new ProgramMap(proto);
+const constructMap = (runner, init, node) => {
+    const target = new Values.Map();
     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);
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
         }
         while (true) {
             const step = yield* cursor.next;
@@ -75,21 +134,21 @@ const constructMap = (runner, init, proto, 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);
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
                 }
                 target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
             }));
         }
     });
 };
-const constructSet = (runner, init, proto, node) => {
-    const target = new ProgramSet(proto);
+const constructSet = (runner, init, node) => {
+    const target = new Values.Set();
     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);
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
         }
         while (true) {
             const step = yield* cursor.next;
@@ -99,247 +158,16 @@ const constructSet = (runner, init, proto, node) => {
         }
     });
 };
-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 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 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,4 +1,3 @@
-import { ProgramObject } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
+import { HostNamespace } from "../interpreter/host.js";
 /** Captured console: every method appends one formatted line to `logs`. */
-export declare const consoleGlobal: <R>(runner: Runner<R>, logs: Array<string>) => ProgramObject;
+export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;

package/dist/stdlib/console.js

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

package/dist/stdlib/date.d.ts

@@ -1,2 +1,8 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
 import { type Runner } from "../interpreter/runner.js";
-export declare const dateGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+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;