@opencode-ai/codemode 0.0.0-dev-17471

package/dist/openapi/types.d.ts

@@ -0,0 +1,122 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import type { Tool, JsonSchema } from "../tool.js";
+/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
+export type Document = Record<string, unknown>;
+/** The operation identity handed to auth resolution and errors. */
+export type Operation = {
+    readonly operationId: string | undefined;
+    readonly method: string;
+    readonly path: string;
+    readonly summary: string | undefined;
+    readonly description: string | undefined;
+};
+/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
+export type SecurityScheme = {
+    readonly type: "apiKey";
+    readonly name: string;
+    readonly in: "header" | "query" | "cookie";
+} | {
+    readonly type: "http";
+    readonly scheme: string;
+} | {
+    readonly type: "oauth2";
+} | {
+    readonly type: "openIdConnect";
+};
+/**
+ * Credential material returned by a host auth resolver. `apiKey` uses the scheme's carrier;
+ * `header` supports nonstandard schemes.
+ */
+export type Credential = {
+    readonly type: "bearer";
+    readonly token: string;
+} | {
+    readonly type: "basic";
+    readonly username: string;
+    readonly password: string;
+} | {
+    readonly type: "apiKey";
+    readonly value: string;
+} | {
+    readonly type: "header";
+    readonly name: string;
+    readonly value: string;
+};
+/**
+ * Resolves credentials at call time. `undefined` tries the next OR alternative; failure aborts.
+ */
+export type AuthResolver = (context: {
+    readonly name: string;
+    readonly definition: SecurityScheme;
+    readonly scopes: ReadonlyArray<string>;
+    readonly operation: Operation;
+}) => Effect.Effect<Credential | undefined, unknown>;
+export type Options = {
+    readonly spec: Document;
+    /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
+    readonly baseUrl?: string | undefined;
+    /** Host credential resolution, keyed by security scheme name. */
+    readonly auth?: {
+        readonly resolve: AuthResolver;
+    } | undefined;
+    /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+};
+/** An operation that could not be represented as a tool, and why. */
+export type Skipped = {
+    readonly method: string;
+    readonly path: string;
+    readonly reason: string;
+};
+export type Tools = {
+    [name: string]: Tool<HttpClient.HttpClient> | Tools;
+};
+export type Result = {
+    /** Namespaced tools; the host places them under a key in its `tools` object. */
+    readonly tools: Tools;
+    readonly skipped: ReadonlyArray<Skipped>;
+};
+export type Parsed<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export type InputLocation = "path" | "query" | "header" | "body";
+export type InputField = {
+    readonly inputName: string;
+    readonly name: string;
+    readonly location: InputLocation;
+    readonly required: boolean;
+    readonly schema: JsonSchema;
+    readonly style: "simple" | "form" | "deepObject" | undefined;
+    readonly explode: boolean | undefined;
+};
+export type Body = {
+    readonly required: boolean;
+    readonly mode: "object" | "value";
+    readonly mediaType: string;
+};
+export type OperationInput = {
+    readonly fields: ReadonlyArray<InputField>;
+    readonly body: Body | undefined;
+};
+export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>;
+export type Plan = {
+    readonly operation: Operation;
+    readonly url: string;
+    readonly fields: ReadonlyArray<InputField>;
+    readonly body: Body | undefined;
+    readonly security: ReadonlyArray<SecurityRequirement>;
+    readonly schemes: Readonly<Record<string, SecurityScheme>>;
+    readonly auth: {
+        readonly resolve: AuthResolver;
+    } | undefined;
+    readonly headers: Readonly<Record<string, string>>;
+};
+export type AppliedAuth = {
+    readonly headers: Readonly<Record<string, string>>;
+    readonly query: Readonly<Record<string, string>>;
+};

package/dist/openapi/types.js

@@ -0,0 +1,2 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";

package/dist/stdlib/collections.d.ts

@@ -0,0 +1,4 @@
+export declare const arrayMethods: Set<string>;
+export declare const mapMethods: Set<string>;
+export declare const mapStatics: Set<string>;
+export declare const setMethods: Set<string>;

package/dist/stdlib/collections.js

@@ -0,0 +1,57 @@
+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 mapStatics = new Set(["groupBy"]);
+export const setMethods = new Set([
+    "add",
+    "has",
+    "delete",
+    "clear",
+    "forEach",
+    "keys",
+    "values",
+    "entries",
+    "union",
+    "intersection",
+    "difference",
+    "symmetricDifference",
+    "isSubsetOf",
+    "isSupersetOf",
+    "isDisjointFrom",
+]);

package/dist/stdlib/console.d.ts

@@ -0,0 +1,2 @@
+export declare const consoleMethods: Set<string>;
+export declare const formatConsoleMessage: (name: string, args: Array<unknown>) => string;

package/dist/stdlib/console.js

@@ -0,0 +1,126 @@
+import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
+import { copyIn, copyOut } from "../tool-runtime.js";
+import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";
+export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"]);
+const MAX_CONSOLE_DEPTH = 32;
+export const formatConsoleMessage = (name, args) => {
+    if (name === "dir")
+        return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
+    if (name === "table")
+        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(" ")}`;
+};
+const formatConsoleArgument = (value) => {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return value;
+    return formatConsoleValue(value, new Set(), 0);
+};
+const formatConsoleValue = (value, seen, depth) => {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (typeof value !== "object")
+        return String(value);
+    if (value instanceof CodeModePromise)
+        return "[Promise (await it to get its value)]";
+    if (value instanceof CodeModeDate)
+        return coerceToString(value);
+    if (value instanceof CodeModeRegExp)
+        return coerceToString(value);
+    if (value instanceof CodeModeURL)
+        return coerceToString(value);
+    if (value instanceof CodeModeURLSearchParams)
+        return coerceToString(value);
+    if (depth > MAX_CONSOLE_DEPTH)
+        return "...";
+    if (seen.has(value))
+        return "[Circular]";
+    if (value instanceof CodeModeMap) {
+        seen.add(value);
+        try {
+            const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
+            return `Map(${value.map.size}) ${formatConsoleValue(entries, seen, depth + 1)}`;
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    if (value instanceof CodeModeSet) {
+        seen.add(value);
+        try {
+            return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    if (isRuntimeReference(value))
+        return "[opaque reference]";
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return `[${value.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
+        }
+        return `{${Object.entries(value)
+            .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
+            .join(",")}}`;
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+const formatConsoleTable = (value, columnsArgument) => {
+    if (value === undefined)
+        return "undefined";
+    if (containsOpaqueReference(value))
+        return "[opaque reference]";
+    const data = boundedData(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))));
+    const header = ["(index)", ...keys].join("\t");
+    return [
+        header,
+        ...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 = copyOut(copyIn(value, "console.table columns"), "nullify");
+    return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
+};
+const consoleTableRows = (data, columns) => {
+    if (Array.isArray(data)) {
+        return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
+    }
+    if (data !== null && typeof data === "object" && !isCodeModeValue(data)) {
+        return Object.entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
+    }
+    return [{ index: "0", values: { Value: data } }];
+};
+const consoleTableValues = (value, columns) => {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !isCodeModeValue(value)) {
+        const source = value;
+        if (columns !== undefined)
+            return Object.fromEntries(columns.map((column) => [column, source[column]]));
+        return Object.fromEntries(Object.entries(source));
+    }
+    return { Value: value };
+};
+const formatConsoleTableCell = (value) => {
+    if (value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    return formatConsoleValue(value, new Set(), 0);
+};

package/dist/stdlib/date.d.ts

@@ -0,0 +1,7 @@
+import { type AstNode } from "../interpreter/model.js";
+import { CodeModeDate } from "../values.js";
+export declare const dateMethods: Set<string>;
+export declare const dateStatics: Set<string>;
+export declare const invokeDateStatic: (name: string, args: Array<unknown>, node: AstNode) => number;
+export declare const dateSetterArgumentCount: (name: string) => number | undefined;
+export declare const invokeDateMethod: (value: CodeModeDate, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;

package/dist/stdlib/date.js

@@ -0,0 +1,186 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { CodeModeDate } from "../values.js";
+import { coerceToNumber, coerceToString } from "./value.js";
+const dateSetterArguments = new Map([
+    ["setTime", 1],
+    ["setMilliseconds", 1],
+    ["setUTCMilliseconds", 1],
+    ["setSeconds", 2],
+    ["setUTCSeconds", 2],
+    ["setMinutes", 3],
+    ["setUTCMinutes", 3],
+    ["setHours", 4],
+    ["setUTCHours", 4],
+    ["setDate", 1],
+    ["setUTCDate", 1],
+    ["setMonth", 2],
+    ["setUTCMonth", 2],
+    ["setFullYear", 3],
+    ["setUTCFullYear", 3],
+]);
+export const dateMethods = new Set([
+    "getTime",
+    "valueOf",
+    "toISOString",
+    "toJSON",
+    "toString",
+    "toUTCString",
+    "toGMTString",
+    "getFullYear",
+    "getMonth",
+    "getDate",
+    "getDay",
+    "getHours",
+    "getMinutes",
+    "getSeconds",
+    "getMilliseconds",
+    "getUTCFullYear",
+    "getUTCMonth",
+    "getUTCDate",
+    "getUTCDay",
+    "getUTCHours",
+    "getUTCMinutes",
+    "getUTCSeconds",
+    "getUTCMilliseconds",
+    "getTimezoneOffset",
+    ...dateSetterArguments.keys(),
+]);
+export const dateStatics = new Set(["now", "parse", "UTC"]);
+export const invokeDateStatic = (name, args, node) => {
+    switch (name) {
+        case "now":
+            return Date.now();
+        case "parse":
+            return Date.parse(coerceToString(args[0]));
+        case "UTC":
+            return Date.UTC(...args.map((arg) => coerceToNumber(arg)));
+        default:
+            throw new InterpreterRuntimeError(`Date.${name} is not available.`, node);
+    }
+};
+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 "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

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { CallbackRunner } from "../interpreter/methods.js";
+import { type AstNode } from "../interpreter/model.js";
+export declare const jsonStatics: Set<string>;
+export type JsonMethodName = "parse" | "stringify";
+export declare const invokeJsonMethod: <R>(runner: CallbackRunner<R>, name: JsonMethodName, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;

package/dist/stdlib/json.js

@@ -0,0 +1,124 @@
+import { Effect } from "effect";
+import { applyCollectionCallback } from "../interpreter/methods.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { typeofValue } from "../interpreter/references.js";
+import { copyIn, copyOut } from "../tool-runtime.js";
+import { CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+export const jsonStatics = new Set(["parse", "stringify"]);
+export const invokeJsonMethod = (runner, name, args, node) => {
+    return name === "parse" ? parse(runner, 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 copyIn(JSON.parse(text), "JSON.parse result");
+        }
+        catch (error) {
+            throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
+        }
+    })();
+    if (typeofValue(args[1]) !== "function")
+        return Effect.succeed(parsed);
+    const apply = applyCollectionCallback(runner, args[1], "JSON.parse", node);
+    const root = Object.create(null);
+    root[""] = parsed;
+    const visit = (holder, key) => Effect.gen(function* () {
+        const value = holder[key];
+        if (Array.isArray(value)) {
+            const length = value.length;
+            for (let index = 0; index < length; index += 1) {
+                const revived = yield* visit(value, String(index));
+                if (revived === undefined)
+                    Reflect.deleteProperty(value, index);
+                else
+                    value[index] = revived;
+            }
+        }
+        else if (isPlainObject(value)) {
+            for (const name of Object.keys(value)) {
+                const revived = yield* visit(value, name);
+                if (revived === undefined)
+                    Reflect.deleteProperty(value, name);
+                else
+                    value[name] = revived;
+            }
+        }
+        return yield* apply([key, value]);
+    });
+    return visit(root, "");
+};
+const stringify = (runner, args, node) => {
+    const space = args[2];
+    const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
+    const replacer = args[1];
+    const callable = typeofValue(replacer) === "function";
+    const checked = copyIn(args[0], "JSON.stringify value", callable);
+    const input = callable ? args[0] : checked;
+    if (Array.isArray(replacer)) {
+        const properties = replacer
+            .filter((item) => typeof item === "string" || typeof item === "number")
+            .map(String);
+        return Effect.succeed(JSON.stringify(copyOut(input, "json"), properties, indent));
+    }
+    if (!callable) {
+        return Effect.succeed(JSON.stringify(copyOut(input, "json"), null, indent));
+    }
+    const apply = applyCollectionCallback(runner, replacer, "JSON.stringify", node);
+    const root = Object.create(null);
+    root[""] = input;
+    const stack = new Set();
+    const visit = (holder, key) => Effect.gen(function* () {
+        const value = yield* apply([key, toJSONValue(holder[key])]);
+        if (value === undefined || typeofValue(value) === "function")
+            return undefined;
+        copyIn(value, "JSON.stringify replacer result", true);
+        if (typeof value === "number")
+            return Number.isFinite(value) ? value : null;
+        if (value === null || typeof value === "string" || typeof value === "boolean")
+            return value;
+        if (Array.isArray(value)) {
+            if (stack.has(value))
+                throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+            stack.add(value);
+            const result = [];
+            for (let index = 0; index < value.length; index += 1) {
+                result.push((yield* visit(value, String(index))) ?? null);
+            }
+            stack.delete(value);
+            return result;
+        }
+        if (!isPlainObject(value))
+            return {};
+        if (stack.has(value))
+            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+        stack.add(value);
+        const result = Object.create(null);
+        for (const name of Object.keys(value)) {
+            const item = yield* visit(value, name);
+            if (item !== undefined)
+                result[name] = item;
+        }
+        stack.delete(value);
+        return result;
+    });
+    return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
+};
+const toJSONValue = (value) => {
+    if (value instanceof CodeModeDate) {
+        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
+    }
+    if (value instanceof CodeModeURL)
+        return value.url.href;
+    return value;
+};
+const isPlainObject = (value) => value !== null &&
+    typeof value === "object" &&
+    !(value instanceof CodeModeDate) &&
+    !(value instanceof CodeModeRegExp) &&
+    !(value instanceof CodeModeMap) &&
+    !(value instanceof CodeModeSet) &&
+    !(value instanceof CodeModeURL) &&
+    !(value instanceof CodeModeURLSearchParams);

package/dist/stdlib/math.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { type SyncIteratorRunner } from "../interpreter/iterator.js";
+import { type AstNode } from "../interpreter/model.js";
+declare global {
+    interface Math {
+        sumPrecise(values: Iterable<number>): number;
+    }
+}
+export declare const mathConstants: Set<string>;
+export declare const mathMethods: Set<string>;
+export declare const invokeMathMethod: (name: string, args: Array<unknown>, node: AstNode) => number;
+export declare const invokeMathSumPrecise: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;