@opencode/codemode 0.0.0-beta-19507 → 0.0.0-dev-19276

package/dist/stdlib/math.js

@@ -1,89 +1,157 @@
 import { Effect } from "effect";
-import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
+import { preserveConsumerError } from "../interpreter/iterator.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-// Validate only the arguments a method consumes; like JS, extras are ignored
-// (so built-ins work as callbacks receiving (element, index, array)).
-const number = (name, args, index, node) => {
-    if (index >= args.length)
-        return Number.NaN;
-    const arg = args[index];
-    if (typeof arg !== "number")
-        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-    return arg;
+export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"]);
+export const mathMethods = new Set([
+    "random",
+    "max",
+    "min",
+    "abs",
+    "acos",
+    "acosh",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "floor",
+    "ceil",
+    "round",
+    "trunc",
+    "sign",
+    "sqrt",
+    "cbrt",
+    "pow",
+    "hypot",
+    "cos",
+    "cosh",
+    "sin",
+    "sinh",
+    "tan",
+    "tanh",
+    "log",
+    "log2",
+    "log10",
+    "log1p",
+    "exp",
+    "expm1",
+    "f16round",
+    "fround",
+    "clz32",
+    "imul",
+    "sumPrecise",
+]);
+export const invokeMathMethod = (name, args, node) => {
+    if (!mathMethods.has(name))
+        throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
+    if (name === "random")
+        return Math.random();
+    // Validate only the arguments the method consumes; like JS, extras are ignored
+    // (so built-ins work as callbacks receiving (element, index, array)).
+    const num = (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);
+        return arg;
+    };
+    const nums = () => args.map((arg) => {
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+        return arg;
+    });
+    const a = num(0);
+    const b = () => num(1);
+    switch (name) {
+        case "max":
+            return Math.max(...nums());
+        case "min":
+            return Math.min(...nums());
+        case "abs":
+            return Math.abs(a);
+        case "acos":
+            return Math.acos(a);
+        case "acosh":
+            return Math.acosh(a);
+        case "asin":
+            return Math.asin(a);
+        case "asinh":
+            return Math.asinh(a);
+        case "atan":
+            return Math.atan(a);
+        case "atan2":
+            return Math.atan2(a, b());
+        case "atanh":
+            return Math.atanh(a);
+        case "floor":
+            return Math.floor(a);
+        case "ceil":
+            return Math.ceil(a);
+        case "round":
+            return Math.round(a);
+        case "trunc":
+            return Math.trunc(a);
+        case "sign":
+            return Math.sign(a);
+        case "sqrt":
+            return Math.sqrt(a);
+        case "cbrt":
+            return Math.cbrt(a);
+        case "pow":
+            return Math.pow(a, b());
+        case "hypot":
+            return Math.hypot(...nums());
+        case "cos":
+            return Math.cos(a);
+        case "cosh":
+            return Math.cosh(a);
+        case "sin":
+            return Math.sin(a);
+        case "sinh":
+            return Math.sinh(a);
+        case "tan":
+            return Math.tan(a);
+        case "tanh":
+            return Math.tanh(a);
+        case "log":
+            return Math.log(a);
+        case "log2":
+            return Math.log2(a);
+        case "log10":
+            return Math.log10(a);
+        case "log1p":
+            return Math.log1p(a);
+        case "exp":
+            return Math.exp(a);
+        case "expm1":
+            return Math.expm1(a);
+        case "f16round":
+            return Math.f16round(a);
+        case "fround":
+            return Math.fround(a);
+        case "clz32":
+            return Math.clz32(a);
+        case "imul":
+            return Math.imul(a, b());
+    }
+    throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
 };
-const unary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node)));
-const binary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node), number(name, args, 1, node)));
-const variadic = (name, op) => sync(`Math.${name}`, (args, node) => op(...args.map((arg) => {
-    if (typeof arg !== "number")
-        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-    return arg;
-})));
-const sumPrecise = (runner) => new HostFunction({
-    name: "Math.sumPrecise",
-    call: (args, node) => Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(args[0], node);
-        if (cursor === undefined) {
-            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
-        }
-        const numbers = [];
-        while (true) {
-            const step = yield* cursor.next;
-            if (step.done)
-                return Math.sumPrecise(numbers);
-            yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (typeof step.value !== "number") {
-                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
-                }
-                numbers.push(step.value);
-            }));
-        }
-    }),
-});
-export const mathGlobal = (runner) => new HostNamespace("Math", {
-    PI: Math.PI,
-    E: Math.E,
-    LN2: Math.LN2,
-    LN10: Math.LN10,
-    LOG2E: Math.LOG2E,
-    LOG10E: Math.LOG10E,
-    SQRT2: Math.SQRT2,
-    SQRT1_2: Math.SQRT1_2,
-    random: sync("Math.random", () => Math.random()),
-    max: variadic("max", Math.max),
-    min: variadic("min", Math.min),
-    hypot: variadic("hypot", Math.hypot),
-    abs: unary("abs", Math.abs),
-    acos: unary("acos", Math.acos),
-    acosh: unary("acosh", Math.acosh),
-    asin: unary("asin", Math.asin),
-    asinh: unary("asinh", Math.asinh),
-    atan: unary("atan", Math.atan),
-    atan2: binary("atan2", Math.atan2),
-    atanh: unary("atanh", Math.atanh),
-    floor: unary("floor", Math.floor),
-    ceil: unary("ceil", Math.ceil),
-    round: unary("round", Math.round),
-    trunc: unary("trunc", Math.trunc),
-    sign: unary("sign", Math.sign),
-    sqrt: unary("sqrt", Math.sqrt),
-    cbrt: unary("cbrt", Math.cbrt),
-    pow: binary("pow", Math.pow),
-    cos: unary("cos", Math.cos),
-    cosh: unary("cosh", Math.cosh),
-    sin: unary("sin", Math.sin),
-    sinh: unary("sinh", Math.sinh),
-    tan: unary("tan", Math.tan),
-    tanh: unary("tanh", Math.tanh),
-    log: unary("log", Math.log),
-    log2: unary("log2", Math.log2),
-    log10: unary("log10", Math.log10),
-    log1p: unary("log1p", Math.log1p),
-    exp: unary("exp", Math.exp),
-    expm1: unary("expm1", Math.expm1),
-    f16round: unary("f16round", Math.f16round),
-    fround: unary("fround", Math.fround),
-    clz32: unary("clz32", Math.clz32),
-    imul: binary("imul", Math.imul),
-    sumPrecise: sumPrecise(runner),
+export const invokeMathSumPrecise = (runner, source, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(source, node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
+    }
+    const numbers = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done)
+            return Math.sumPrecise(numbers);
+        yield* preserveConsumerError(cursor, Effect.sync(() => {
+            if (typeof step.value !== "number") {
+                throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
+            }
+            numbers.push(step.value);
+        }));
+    }
 });

package/dist/stdlib/number.d.ts

@@ -1,4 +1,6 @@
-import { type AstNode } from "../interpreter/model.js";
 export declare const numberMethods: Set<string>;
+export declare const numberConstants: Set<string>;
+export declare const numberStatics: Set<string>;
 export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
-export declare const numberGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const invokeNumberStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/number.js

@@ -1,8 +1,15 @@
-import { toProgram } from "../data.js";
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { coercion, coerceToString } from "./value.js";
 export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
+export const numberConstants = new Set([
+    "MAX_SAFE_INTEGER",
+    "MIN_SAFE_INTEGER",
+    "MAX_VALUE",
+    "MIN_VALUE",
+    "EPSILON",
+    "NaN",
+    "POSITIVE_INFINITY",
+    "NEGATIVE_INFINITY",
+]);
+export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"]);
 export const invokeNumberMethod = (value, name, args, node) => {
     const optNum = (index) => {
         const arg = args[index];
@@ -39,31 +46,31 @@ export const invokeNumberMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`Number method '${name}' is not available.`, node);
     }
-    return toProgram(result, `Number.${name} result`);
+    return boundedData(result, `Number.${name} result`);
 };
-const parseIntStatic = sync("Number.parseInt", (args, node) => {
-    const radix = args[1];
-    if (radix !== undefined && typeof radix !== "number") {
-        throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
+export const invokeNumberStatic = (name, args, node) => {
+    const value = args[0];
+    switch (name) {
+        case "isInteger":
+            return Number.isInteger(value);
+        case "isFinite":
+            return Number.isFinite(value);
+        case "isNaN":
+            return Number.isNaN(value);
+        case "isSafeInteger":
+            return Number.isSafeInteger(value);
+        case "parseInt": {
+            const radix = args[1];
+            if (radix !== undefined && typeof radix !== "number") {
+                throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
+            }
+            return parseInt(coerceToString(value), radix);
+        }
+        case "parseFloat":
+            return parseFloat(coerceToString(value));
+        default:
+            throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
     }
-    return parseInt(coerceToString(args[0]), radix);
-});
-export const numberGlobal = coercion("Number", {
-    instanceOf: () => false,
-    members: {
-        MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
-        MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
-        MAX_VALUE: Number.MAX_VALUE,
-        MIN_VALUE: Number.MIN_VALUE,
-        EPSILON: Number.EPSILON,
-        NaN: Number.NaN,
-        POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
-        NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
-        isInteger: sync("Number.isInteger", (args) => Number.isInteger(args[0])),
-        isFinite: sync("Number.isFinite", (args) => Number.isFinite(args[0])),
-        isNaN: sync("Number.isNaN", (args) => Number.isNaN(args[0])),
-        isSafeInteger: sync("Number.isSafeInteger", (args) => Number.isSafeInteger(args[0])),
-        parseInt: parseIntStatic,
-        parseFloat: sync("Number.parseFloat", (args) => parseFloat(coerceToString(args[0]))),
-    },
-});
+};
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/object.d.ts

@@ -1,7 +1,7 @@
-import { HostFunction } from "../interpreter/host.js";
+import { Effect } from "effect";
 import { type AstNode } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const enumerableSource: (label: string, value: unknown, node: AstNode) => ProgramObject;
-export declare const objectAssign: (args: Array<unknown>, node: AstNode) => unknown;
-export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => HostFunction<R>;
+import { type SyncIteratorRunner } from "../interpreter/iterator.js";
+export declare const objectMethodsPreservingIdentity: Set<string>;
+export declare const objectStatics: Set<string>;
+export declare const invokeObjectMethod: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeObjectFromEntries: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<Record<string, unknown>, unknown, R>;

package/dist/stdlib/object.js

@@ -1,55 +1,85 @@
 import { Effect } from "effect";
-import { toProgram } from "../data.js";
-import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
-import { getOwn, hasOwn, ownEntries, ownKeys, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
-import { ToolReference } from "../tool-runtime.js";
-import { Values } from "../values.js";
-import { groupBy } from "./collections.js";
-import { coerceToString } from "./value.js";
-// ToObject for enumeration.
-export const enumerableSource = (label, value, node) => {
-    if (value === null || value === undefined) {
-        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
-    }
-    if (value instanceof Values.Promise) {
-        throw new InterpreterRuntimeError(`${label} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
-    }
-    if (value instanceof ToolReference) {
-        throw new InterpreterRuntimeError(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
-    }
-    if (typeof value === "string")
-        return new ProgramArray([...value]);
-    if (value instanceof ProgramObject)
-        return value;
-    return new ProgramObject();
-};
-export const objectAssign = (args, node) => {
-    const target = args[0];
-    // JS would box a primitive target; wrappers and primitives cannot hold fields here.
-    if (!(target instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node).as("TypeError");
-    }
-    const seen = new Set();
-    for (const source of args.slice(1)) {
-        if (source === null || source === undefined)
-            continue;
-        const from = enumerableSource("Object.assign(...)", source, node);
-        for (const key of ownKeys(from)) {
-            if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
-                continue;
-            rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", node, seen);
-            if (!set(target, key, getOwn(from, key))) {
-                throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+import { containsOpaqueReference, rejectCircularInsertion } from "../interpreter/references.js";
+import { isBlockedMember } from "../tool-runtime.js";
+import { isCodeModeValue, CodeModePromise } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";
+import { preserveConsumerError } from "../interpreter/iterator.js";
+export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"]);
+export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries", "groupBy"]);
+export const invokeObjectMethod = (name, args, node) => {
+    const requireObject = () => {
+        const input = args[0];
+        if (Array.isArray(input))
+            return input;
+        if (isCodeModeValue(input))
+            return {};
+        if (input instanceof CodeModePromise) {
+            throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+        }
+        if (input === null || typeof input !== "object") {
+            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+        }
+        const prototype = Object.getPrototypeOf(input);
+        if (prototype !== null && prototype !== Object.prototype) {
+            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+        }
+        return input;
+    };
+    switch (name) {
+        case "keys":
+            return Object.keys(requireObject());
+        case "values":
+            return Object.values(requireObject());
+        case "entries":
+            return Object.entries(requireObject()).map(([key, item]) => [key, item]);
+        case "hasOwn":
+            return Object.hasOwn(requireObject(), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]));
+        case "is":
+            if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
+                throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
             }
+            return Object.is(args[0], args[1]);
+        case "assign": {
+            const target = args[0];
+            if (target === null || typeof target !== "object" || Array.isArray(target) || isCodeModeValue(target)) {
+                throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
+            }
+            const out = target;
+            const seen = new Set();
+            const guardedSet = (key, item) => {
+                if (typeof key === "string" && isBlockedMember(key))
+                    throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
+                rejectCircularInsertion(out, item, "Object.assign result", node, seen);
+                if (!Reflect.set(out, key, item))
+                    throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
+            };
+            for (const source of args.slice(1)) {
+                if (source === null || source === undefined || isCodeModeValue(source))
+                    continue;
+                if (typeof source !== "object" || Array.isArray(source)) {
+                    throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
+                }
+                for (const key of Reflect.ownKeys(source)) {
+                    if (typeof key === "string") {
+                        if (Object.prototype.propertyIsEnumerable.call(source, key))
+                            guardedSet(key, Reflect.get(source, key));
+                        continue;
+                    }
+                    if (key !== AsyncIteratorSymbol && key !== IteratorSymbol)
+                        continue;
+                    if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                        continue;
+                    guardedSet(key, Reflect.get(source, key));
+                }
+            }
+            return out;
         }
     }
-    return target;
+    throw new InterpreterRuntimeError(`Object.${name} is not available.`, node);
 };
-const objectFromEntries = (runner, source, node) => {
-    const out = new ProgramObject();
+export const invokeObjectFromEntries = (runner, source, node) => {
+    const out = Object.create(null);
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(source, node);
         if (cursor === undefined) {
@@ -60,47 +90,20 @@ const objectFromEntries = (runner, source, node) => {
             if (step.done)
                 return out;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
+                if (step.value === null ||
+                    typeof step.value !== "object" ||
+                    isCodeModeValue(step.value) ||
+                    containsOpaqueReference(step.value)) {
                     throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }
-                set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
+                const entry = step.value;
+                boundedData(entry[0], "Object.fromEntries key");
+                boundedData(entry[1], "Object.fromEntries value");
+                const key = coerceToString(entry[0]);
+                if (isBlockedMember(key))
+                    throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
+                out[key] = entry[1];
             }));
         }
     });
 };
-const constructObject = (args, node) => {
-    const first = args[0];
-    if (first === null || first === undefined)
-        return new ProgramObject();
-    if (typeof first === "object")
-        return first;
-    throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
-};
-// Object constructs identically with or without new, like JS. Only `keys` copies its result into the
-// program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
-export const objectGlobal = (runner, toolKeys) => new HostFunction({
-    name: "Object",
-    call: syncCall(constructObject),
-    construct: syncCall(constructObject),
-    instanceOf: (value) => value !== null && (typeof value === "object" || typeofValue(value) === "function"),
-    members: {
-        keys: sync("Object.keys", (args, node) => toProgram(args[0] instanceof ToolReference
-            ? [...toolKeys(args[0].path)]
-            : ownKeys(enumerableSource("Object.keys(...)", args[0], node)).filter((key) => typeof key === "string"), "Object.keys result")),
-        values: sync("Object.values", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.values(...)", args[0], node)).map((entry) => entry[1]))),
-        entries: sync("Object.entries", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.entries(...)", args[0], node)).map((entry) => new ProgramArray(entry)))),
-        hasOwn: sync("Object.hasOwn", (args, node) => hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
-        is: sync("Object.is", (args, node) => {
-            if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
-            }
-            return Object.is(args[0], args[1]);
-        }),
-        assign: sync("Object.assign", objectAssign),
-        fromEntries: new HostFunction({
-            name: "Object.fromEntries",
-            call: (args, node) => Effect.suspend(() => objectFromEntries(runner, args[0], node)),
-        }),
-        groupBy: groupBy(runner, "Object"),
-    },
-});

package/dist/stdlib/promise.d.ts

@@ -0,0 +1,2 @@
+import type { PromiseMethodName } from "../interpreter/model.js";
+export declare const promiseStatics: Set<PromiseMethodName>;

package/dist/stdlib/promise.js

@@ -0,0 +1 @@
+export const promiseStatics = new Set(["all", "allSettled", "race", "any", "resolve", "reject"]);

package/dist/stdlib/regexp.d.ts

@@ -1,10 +1,11 @@
 import { type AstNode } from "../interpreter/model.js";
-import { ProgramArray } from "../interpreter/objects.js";
-import { Values } from "../values.js";
+import { CodeModeRegExp } from "../values.js";
 export declare const regexpMethods: Set<string>;
+export declare const regexpStatics: Set<string>;
 export declare const regexpProperties: Set<string>;
+export declare const regexFailureReason: (error: unknown) => string;
+export declare const escapeRegexHint = "To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. \"\\\\(\") or test for them with String.includes instead.";
 export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
-export declare const matchToValue: (match: RegExpMatchArray) => ProgramArray;
-export declare const constructRegExp: (args: Array<unknown>, node: AstNode) => Values.RegExp;
-export declare const regexpGlobal: import("../interpreter/host.js").HostFunction<never>;
-export declare const invokeRegExpMethod: (value: Values.RegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
+export declare const invokeRegExpStatic: (name: string, args: Array<unknown>, node: AstNode) => string;
+export declare const invokeRegExpMethod: (value: CodeModeRegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;