@opencode/codemode 0.0.0-beta-19500 → 0.0.0-dev-19274

package/dist/interpreter/host.js

@@ -1,44 +0,0 @@
-import { Effect } from "effect";
-import { InterpreterRuntimeError } from "./model.js";
-/** A host-implemented function value. `typeof` is "function". */
-export class HostFunction {
-    name;
-    call;
-    construct;
-    member;
-    instanceOf;
-    callback;
-    constructor(options) {
-        this.name = options.name;
-        this.call = options.call;
-        this.construct = options.construct;
-        this.member = memberLookup(options.members);
-        this.instanceOf = options.instanceOf;
-        this.callback = options.callback ?? true;
-    }
-}
-/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
-export class HostNamespace {
-    name;
-    member;
-    constructor(name, members) {
-        this.name = name;
-        this.member = memberLookup(members);
-    }
-}
-const memberLookup = (members) => {
-    if (members === undefined)
-        return () => undefined;
-    if (typeof members === "function")
-        return members;
-    const table = new Map(Object.entries(members));
-    return (key) => (typeof key === "string" ? table.get(key) : undefined);
-};
-/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
-export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, node));
-/** A synchronous host function. */
-export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
-/** The `call` of a constructor that JS requires to be invoked with `new`. */
-export const requiresNew = (name) => (_, node) => Effect.sync(() => {
-    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node).as("TypeError");
-});

package/dist/interpreter/objects.d.ts

@@ -1,37 +0,0 @@
-import type { BlockStatement, Expression, Pattern } from "acorn";
-import { type Binding } from "./model.js";
-/** An object owned by the program: own properties plus a prototype link. */
-export declare class ProgramObject {
-    proto: ProgramObject | null;
-    readonly props: Map<PropertyKey, unknown>;
-    constructor(proto?: ProgramObject | null);
-}
-export declare class ProgramArray extends ProgramObject {
-    readonly items: Array<unknown>;
-    constructor(items?: Array<unknown>);
-}
-export declare class ProgramError extends ProgramObject {
-    readonly errorName: string;
-    constructor(errorName: string);
-}
-export declare class ProgramFunction extends ProgramObject {
-    readonly name: string;
-    readonly parameters: ReadonlyArray<Pattern>;
-    readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
-    readonly async: boolean;
-    readonly generator: boolean;
-    readonly length: number;
-    constructor(name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
-}
-export declare const parseArrayIndex: (key: string | number) => number | undefined;
-export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
-export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;
-export declare const get: (target: ProgramObject, key: PropertyKey) => unknown;
-export declare const has: (target: ProgramObject, key: PropertyKey) => boolean;
-export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
-export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
-export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
-export declare const ownEntries: (target: ProgramObject) => Array<[string, unknown]>;
-export declare const record: (entries: Record<string, unknown>) => ProgramObject;
-export declare const assign: (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -1,151 +0,0 @@
-import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
-/** An object owned by the program: own properties plus a prototype link. */
-export class ProgramObject {
-    proto;
-    props = new Map();
-    constructor(proto = null) {
-        this.proto = proto;
-    }
-}
-export class ProgramArray extends ProgramObject {
-    items;
-    constructor(items = []) {
-        super();
-        this.items = items;
-    }
-}
-export class ProgramError extends ProgramObject {
-    errorName;
-    constructor(errorName) {
-        super();
-        this.errorName = errorName;
-    }
-}
-export class ProgramFunction extends ProgramObject {
-    name;
-    parameters;
-    body;
-    capturedScopes;
-    async;
-    generator;
-    length;
-    constructor(name, parameters, body, capturedScopes, async, generator) {
-        super();
-        this.name = name;
-        this.parameters = parameters;
-        this.body = body;
-        this.capturedScopes = capturedScopes;
-        this.async = async;
-        this.generator = generator;
-        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
-        this.length = optional === -1 ? parameters.length : optional;
-    }
-}
-const MAX_ARRAY_LENGTH = 4_294_967_295;
-export const parseArrayIndex = (key) => {
-    const property = String(key);
-    if (!/^(0|[1-9]\d*)$/.test(property))
-        return undefined;
-    const index = Number(property);
-    return index < MAX_ARRAY_LENGTH ? index : undefined;
-};
-const canonical = (key) => (typeof key === "symbol" ? key : String(key));
-const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
-// Non-enumerable built-in properties: array length, function name and length.
-const builtin = (target, name) => (name === "length" && target instanceof ProgramArray) ||
-    ((name === "name" || name === "length") && target instanceof ProgramFunction);
-export const hasOwn = (target, key) => {
-    const name = canonical(key);
-    const at = index(target, name);
-    if (at !== undefined)
-        return at in target.items;
-    return builtin(target, name) || target.props.has(name);
-};
-export const getOwn = (target, key) => {
-    const name = canonical(key);
-    const at = index(target, name);
-    if (at !== undefined)
-        return target.items[at];
-    if (target instanceof ProgramArray && name === "length")
-        return target.items.length;
-    if (target instanceof ProgramFunction && name === "name")
-        return target.name;
-    if (target instanceof ProgramFunction && name === "length")
-        return target.length;
-    return target.props.get(name);
-};
-export const get = (target, key) => {
-    for (let current = target; current !== null; current = current.proto) {
-        if (hasOwn(current, key))
-            return getOwn(current, key);
-    }
-    return undefined;
-};
-export const has = (target, key) => {
-    for (let current = target; current !== null; current = current.proto) {
-        if (hasOwn(current, key))
-            return true;
-    }
-    return false;
-};
-export const set = (target, key, value) => {
-    const name = canonical(key);
-    const at = index(target, name);
-    if (at !== undefined) {
-        ;
-        target.items[at] = value;
-        return true;
-    }
-    if (name === "length" && target instanceof ProgramArray) {
-        const length = typeof value === "number" ? value : Number(value);
-        if (!Number.isInteger(length) || length < 0 || length > 4_294_967_295)
-            return false;
-        target.items.length = length;
-        return true;
-    }
-    if (builtin(target, name))
-        return false;
-    target.props.set(name, value);
-    return true;
-};
-export const remove = (target, key) => {
-    const name = canonical(key);
-    const at = index(target, name);
-    if (at !== undefined)
-        return delete target.items[at];
-    if (name === "length" && target instanceof ProgramArray)
-        return false;
-    if (builtin(target, name))
-        return true;
-    target.props.delete(name);
-    return true;
-};
-// JS order: array indexes, integer-like keys ascending, other strings, then symbols.
-export const ownKeys = (target) => {
-    const strings = [...target.props.keys()].filter((key) => typeof key === "string");
-    const symbols = [...target.props.keys()].filter((key) => typeof key === "symbol");
-    return [
-        ...(target instanceof ProgramArray ? Object.keys(target.items) : []),
-        ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
-        ...strings.filter((key) => parseArrayIndex(key) === undefined),
-        ...symbols,
-    ];
-};
-export const ownEntries = (target) => ownKeys(target)
-    .filter((key) => typeof key === "string")
-    .map((key) => [key, getOwn(target, key)]);
-export const record = (entries) => {
-    const target = new ProgramObject();
-    for (const [key, value] of Object.entries(entries))
-        set(target, key, value);
-    return target;
-};
-export const assign = (target, source, skip) => {
-    for (const key of ownKeys(source)) {
-        if (skip?.has(key))
-            continue;
-        if (typeof key === "symbol" && key !== IteratorSymbol && key !== AsyncIteratorSymbol)
-            continue;
-        set(target, key, getOwn(source, key));
-    }
-};

package/dist/interpreter/runner.d.ts

@@ -1,24 +0,0 @@
-import { Effect } from "effect";
-import { Values } from "../values.js";
-import { HostFunction } from "./host.js";
-import { type AstNode, IntrinsicReference } from "./model.js";
-import { ProgramFunction } from "./objects.js";
-export type IteratorCursor<R> = {
-    readonly next: Effect.Effect<{
-        readonly done: boolean;
-        readonly value: unknown;
-    }, unknown, R>;
-    readonly close: Effect.Effect<void, unknown, R>;
-};
-/** Everything a host function needs to call back into the program. */
-export type Runner<R> = {
-    readonly invokeFunction: (fn: ProgramFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
-    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
-};
-export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
-export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export type SupportedCallback = ProgramFunction | HostFunction<unknown> | IntrinsicReference;
-export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
-export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/runner.js

@@ -1,45 +0,0 @@
-import { Effect, Exit } from "effect";
-import { Values } from "../values.js";
-import { coerceToString } from "../stdlib/value.js";
-import { HostFunction } from "./host.js";
-import { InterpreterRuntimeError, IntrinsicReference } from "./model.js";
-import { get, has, ProgramFunction, ProgramObject } from "./objects.js";
-import { typeofValue } from "./references.js";
-export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
-    ? Effect.succeed(exit.value)
-    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));
-export const toPrimitive = (runner, value, hint, node) => {
-    if (value === null || typeof value !== "object")
-        return Effect.succeed(value);
-    if (Values.isValue(value)) {
-        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
-    }
-    if (!(value instanceof ProgramObject))
-        return Effect.succeed(value);
-    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
-    return Effect.gen(function* () {
-        for (const method of order) {
-            if (method === "toString" && !has(value, "toString"))
-                return coerceToString(value);
-            const callable = get(value, method);
-            if (typeofValue(callable) !== "function")
-                continue;
-            const result = yield* runner.invokeCallable(callable, [], node);
-            if (result === null || (typeof result !== "object" && typeof result !== "function"))
-                return result;
-        }
-        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
-    });
-};
-export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
-    (value instanceof HostFunction && value.callback) ||
-    value instanceof IntrinsicReference;
-export const applyCollectionCallback = (runner, callback, name, node) => {
-    if (!isSupportedCallback(callback)) {
-        if (typeofValue(callback) === "function") {
-            throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
-        }
-        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
-    }
-    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
-};

package/dist/stdlib/array.d.ts

@@ -1,3 +0,0 @@
-import { HostFunction } from "../interpreter/host.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const arrayGlobal: <R>(runner: Runner<R>) => HostFunction<R>;

package/dist/stdlib/array.js

@@ -1,68 +0,0 @@
-import { Effect } from "effect";
-import { HostFunction, sync, syncCall } from "../interpreter/host.js";
-import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
-import { get, ProgramArray, ProgramObject } from "../interpreter/objects.js";
-import { describeValue } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
-const constructArray = (args, node) => {
-    if (args.length !== 1)
-        return new ProgramArray([...args]);
-    const first = args[0];
-    if (typeof first !== "number")
-        return new ProgramArray([first]);
-    if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
-        throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
-    }
-    // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
-    return new ProgramArray(new Array(first));
-};
-const arrayLikeSource = (source, node) => {
-    if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
-        const length = get(source, "length");
-        const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        if (normalized > 4_294_967_295)
-            throw new RangeError("Invalid array length");
-        return { length: normalized, source };
-    }
-    throw new InterpreterRuntimeError(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`, node, "InvalidDataValue");
-};
-const arrayFrom = (runner, args, node) => {
-    const source = args[0];
-    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node);
-    return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
-        if (cursor === undefined) {
-            if (source instanceof CodeModeGenerator) {
-                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as("TypeError");
-            }
-            const arrayLike = arrayLikeSource(source, node);
-            const values = [];
-            for (let index = 0; index < arrayLike.length; index += 1) {
-                const item = get(arrayLike.source, index);
-                values.push(apply === undefined ? item : yield* apply([item, index]));
-            }
-            return new ProgramArray(values);
-        }
-        const values = [];
-        let index = 0;
-        while (true) {
-            const step = yield* cursor.next;
-            if (step.done)
-                return new ProgramArray(values);
-            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
-            index += 1;
-        }
-    });
-};
-// Array constructs identically with or without new, like JS.
-export const arrayGlobal = (runner) => new HostFunction({
-    name: "Array",
-    call: syncCall(constructArray),
-    construct: syncCall(constructArray),
-    instanceOf: (value) => value instanceof ProgramArray,
-    members: {
-        isArray: sync("Array.isArray", (args) => args[0] instanceof ProgramArray),
-        of: sync("Array.of", (args) => new ProgramArray([...args])),
-        from: new HostFunction({ name: "Array.from", call: (args, node) => arrayFrom(runner, args, node) }),
-    },
-});

package/dist/stdlib/web.d.ts

@@ -1,4 +0,0 @@
-import { HostNamespace } from "../interpreter/host.js";
-export declare const atobGlobal: import("../interpreter/host.js").HostFunction<never>;
-export declare const btoaGlobal: import("../interpreter/host.js").HostFunction<never>;
-export declare const cryptoGlobal: HostNamespace;

package/dist/stdlib/web.js

@@ -1,20 +0,0 @@
-import { HostNamespace, sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { coerceToString } from "./value.js";
-// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
-const base64 = (name) => sync(name, (args, node) => {
-    if (args.length === 0)
-        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError");
-    const input = coerceToString(args[0]);
-    try {
-        return name === "atob" ? atob(input) : btoa(input);
-    }
-    catch {
-        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
-    }
-});
-export const atobGlobal = base64("atob");
-export const btoaGlobal = base64("btoa");
-export const cryptoGlobal = new HostNamespace("crypto", {
-    randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
-});