@uicast/core 0.0.1-beta.2 → 0.0.2

package/dist/expr/analyze.js

@@ -1,189 +0,0 @@
-import { childNodes } from "./ast-utils.js";
-// Static analysis of a parsed expression (not the security check — that's
-// validate.ts). Two things the renderer needs: whether the expr is async
-// (containsAwait), and which scopes.X.Y paths it reads (extractScopeReads), so it
-// can subscribe without the LLM writing a deps array.
-/** Does the expression `await` anything? */
-export function containsAwait(node) {
-    if (!node || typeof node !== "object")
-        return false;
-    if (node.type === "AwaitExpression")
-        return true;
-    for (const child of childNodes(node)) {
-        if (containsAwait(child))
-            return true;
-    }
-    return false;
-}
-// Collect every static scopes.X.Y chain the expression reads, stopping at the
-// first dynamic segment (computed key, call, non-identifier property). A method
-// call drops its last segment (rows.filter(...) depends on rows, not .filter).
-// The test file pins the trickier cases.
-// Read a member chain into its identifier segments (`a.b.c` -> ["a","b","c"]), or
-// null if it hits a computed / non-identifier segment.
-function collectChain(node) {
-    const parts = [];
-    let cur = node;
-    while (cur) {
-        if (cur.type === "MemberExpression") {
-            if (cur.computed)
-                return null;
-            const prop = cur.property;
-            if (prop.type !== "Identifier")
-                return null;
-            parts.unshift(prop.name);
-            cur = cur.object;
-        }
-        else if (cur.type === "Identifier") {
-            parts.unshift(cur.name);
-            return parts;
-        }
-        else {
-            return null;
-        }
-    }
-    return null;
-}
-// A computed key can read scopes itself (`scopes.x[scopes.y]`), so walk the
-// computed parts of a chain too.
-function walkComputedKeysWithin(memberExpr, out) {
-    let cur = memberExpr;
-    while (cur.type === "MemberExpression") {
-        if (cur.computed) {
-            walkScopeReads(cur.property, out);
-        }
-        cur = cur.object;
-    }
-}
-// The recursive walker behind extractScopeReads().
-function walkScopeReads(node, out) {
-    if (!node || typeof node !== "object")
-        return;
-    // A method call depends on the chain, not the method name — record the chain
-    // without the method, then recurse args.
-    if (node.type === "CallExpression") {
-        const callee = node.callee;
-        if (callee.type === "MemberExpression" && !callee.computed) {
-            const chain = collectChain(callee.object);
-            if (chain && chain[0] === "scopes" && chain.length > 1) {
-                out.add(chain.join("."));
-                walkComputedKeysWithin(callee.object, out);
-            }
-            else {
-                walkScopeReads(callee.object, out);
-            }
-        }
-        else {
-            walkScopeReads(callee, out);
-        }
-        for (const arg of node.arguments) {
-            walkScopeReads(arg, out);
-        }
-        return;
-    }
-    // A plain member read: take the chain if it's rooted at `scopes`.
-    if (node.type === "MemberExpression") {
-        const chain = collectChain(node);
-        if (chain && chain[0] === "scopes" && chain.length > 1) {
-            out.add(chain.join("."));
-            walkComputedKeysWithin(node, out);
-            return;
-        }
-        // Not a scopes chain (or it hit a computed segment) — recurse for nested reads.
-        walkScopeReads(node.object, out);
-        if (node.computed) {
-            walkScopeReads(node.property, out);
-        }
-        return;
-    }
-    for (const child of childNodes(node)) {
-        walkScopeReads(child, out);
-    }
-}
-export function extractScopeReads(ast) {
-    const out = new Set();
-    walkScopeReads(ast, out);
-    return [...out];
-}
-// Free identifiers — names read from the outer scope (globals + injected
-// context). Anything bound by a param, destructuring, or a local declaration
-// stays internal and is not reported.
-function bindPattern(node, scope) {
-    if (!node)
-        return;
-    if (node.type === "Identifier") {
-        scope.add(node.name);
-    }
-    else if (node.type === "ObjectPattern") {
-        for (const p of node.properties)
-            bindPattern(p.type === "RestElement" ? p.argument : p.value, scope);
-    }
-    else if (node.type === "ArrayPattern") {
-        for (const el of node.elements)
-            if (el)
-                bindPattern(el, scope);
-    }
-    else if (node.type === "AssignmentPattern") {
-        bindPattern(node.left, scope);
-    }
-    else if (node.type === "RestElement") {
-        bindPattern(node.argument, scope);
-    }
-}
-function isBound(name, stack) {
-    for (let i = stack.length - 1; i >= 0; i--)
-        if (stack[i].has(name))
-            return true;
-    return false;
-}
-function walkFree(node, stack, out) {
-    if (!node || typeof node !== "object")
-        return;
-    switch (node.type) {
-        case "Identifier":
-            if (!isBound(node.name, stack))
-                out.add(node.name);
-            return;
-        case "MemberExpression":
-            walkFree(node.object, stack, out);
-            if (node.computed)
-                walkFree(node.property, stack, out);
-            return;
-        case "Property":
-            if (node.computed)
-                walkFree(node.key, stack, out);
-            walkFree(node.value, stack, out);
-            return;
-        case "VariableDeclarator":
-            bindPattern(node.id, stack[stack.length - 1]);
-            walkFree(node.init, stack, out);
-            return;
-        case "ArrowFunctionExpression":
-        case "FunctionExpression": {
-            const scope = new Set();
-            if (node.type === "FunctionExpression" && node.id)
-                scope.add(node.id.name);
-            for (const p of node.params)
-                bindPattern(p, scope);
-            const inner = [...stack, scope];
-            for (const p of node.params)
-                walkFree(p, inner, out);
-            walkFree(node.body, inner, out);
-            return;
-        }
-        case "CatchClause": {
-            const scope = new Set();
-            if (node.param)
-                bindPattern(node.param, scope);
-            walkFree(node.body, [...stack, scope], out);
-            return;
-        }
-    }
-    for (const child of childNodes(node))
-        walkFree(child, stack, out);
-}
-export function extractFreeIdentifiers(ast) {
-    const out = new Set();
-    walkFree(ast, [new Set()], out);
-    return [...out];
-}

package/dist/expr/ast-utils.d.ts

@@ -1,4 +0,0 @@
-import type * as acorn from "acorn";
-/** Runtime guard: does `x` look like an AST node (object with a string `type`)? */
-export declare function isNode(x: unknown): x is acorn.AnyNode;
-export declare function childNodes(node: acorn.AnyNode): acorn.AnyNode[];

package/dist/expr/ast-utils.js

@@ -1,23 +0,0 @@
-// Low-level acorn-AST helpers shared by validate.ts and analyze.ts. NOT a parser
-// — acorn parses; these are a node type-guard and a child-traversal helper.
-/** Runtime guard: does `x` look like an AST node (object with a string `type`)? */
-export function isNode(x) {
-    return (typeof x === "object" &&
-        x !== null &&
-        typeof x.type === "string");
-}
-// Direct child nodes, flattening array-valued fields — for key-agnostic walks.
-export function childNodes(node) {
-    const out = [];
-    for (const value of Object.values(node)) {
-        if (Array.isArray(value)) {
-            for (const child of value)
-                if (isNode(child))
-                    out.push(child);
-        }
-        else if (isNode(value)) {
-            out.push(value);
-        }
-    }
-    return out;
-}

package/dist/expr/globals.d.ts

@@ -1,3 +0,0 @@
-/** Globals an expression may reference. Every entry is also usable with `new`. */
-export declare const ALLOWED_GLOBALS: string[];
-export declare const GLOBALS_TO_SHADOW: string[];

package/dist/expr/globals.js

@@ -1,111 +0,0 @@
-// Which JavaScript globals an expression can see. The engine enforces an
-// allowlist (safer-eval.ts): a free identifier that is neither an allowed global
-// nor an injected context name is rejected before the expression runs.
-// ALLOWED_GLOBALS is that list — also handed to SaferEval as allowGlobals and
-// shown to the LLM in the prompt. GLOBALS_TO_SHADOW are bound to undefined as a
-// second line of defence, so an allowed-by-mistake reference still stays inert.
-/** Globals an expression may reference. Every entry is also usable with `new`. */
-export const ALLOWED_GLOBALS = [
-    // Namespaces / utilities
-    "Math",
-    "JSON",
-    "Intl",
-    "Object",
-    "Array",
-    // Coercion (use as calls — `new Number(x)` etc. boxes the value)
-    "Number",
-    "String",
-    "Boolean",
-    "parseInt",
-    "parseFloat",
-    // Predicates / constants
-    "isNaN",
-    "isFinite",
-    "undefined",
-    "NaN",
-    "Infinity",
-    // URI helpers
-    "encodeURIComponent",
-    "decodeURIComponent",
-    "encodeURI",
-    "decodeURI",
-    // Constructors & async
-    "Date",
-    "Map",
-    "Set",
-    "RegExp",
-    "URL",
-    "URLSearchParams",
-    "Promise",
-    "BigInt",
-    // Error constructors
-    "Error",
-    "TypeError",
-    "RangeError",
-    "SyntaxError",
-    "ReferenceError",
-    "EvalError",
-    "URIError",
-    "AggregateError",
-];
-// Capability globals shadowed to undefined. (`eval` / `arguments` can't be param
-// names in strict mode — blocked in validate.ts instead.)
-export const GLOBALS_TO_SHADOW = [
-    // Global objects
-    "globalThis",
-    "self",
-    "window",
-    "global",
-    "document",
-    "navigator",
-    "location",
-    "history",
-    "localStorage",
-    "sessionStorage",
-    "indexedDB",
-    // Network / IO
-    "fetch",
-    "XMLHttpRequest",
-    "WebSocket",
-    "EventSource",
-    "Worker",
-    "SharedWorker",
-    "ServiceWorker",
-    "importScripts",
-    // Fire a network request via `.src` — an exfiltration channel even with fetch
-    // shadowed.
-    "Image",
-    "Audio",
-    // Code execution
-    "Function",
-    "WebAssembly", // runs arbitrary code
-    "setTimeout",
-    "setInterval",
-    "setImmediate",
-    "requestAnimationFrame",
-    "requestIdleCallback",
-    "queueMicrotask",
-    // Process / non-browser runtimes
-    "process",
-    "require",
-    "module",
-    "exports",
-    "__dirname",
-    "__filename",
-    "Buffer",
-    "Deno", // runtime god-object (fs/net/env) outside a browser
-    "Bun",
-    // DOM
-    "alert",
-    "confirm",
-    "prompt",
-    "close",
-    "open",
-    "print",
-    "postMessage",
-    // Constructors that can escape
-    "Proxy",
-    "Reflect",
-    "SharedArrayBuffer",
-    "Atomics",
-];

package/dist/expr/safer-eval.d.ts

@@ -1,21 +0,0 @@
-import { SaferEvalError } from "./validate.js";
-export { SaferEvalError };
-export declare class SaferEval {
-    #private;
-    constructor(options?: {
-        maxCacheSize?: number;
-        extraGlobalsToShadow?: string[];
-        allowGlobals?: string[];
-        enforceAllowlist?: boolean;
-    });
-    validate(expression: string): {
-        isAsync: boolean;
-        scopeReads: string[];
-        freeIds: string[];
-    };
-    compile(expression: string): (context: Record<string, unknown>) => unknown;
-    isAsync(expression: string): boolean;
-    scopeReads(expression: string): string[];
-    eval(expression: string, context?: Record<string, unknown>, allowedGlobals?: string[]): unknown;
-    clearCache(): void;
-}

package/dist/expr/safer-eval.js

@@ -1,170 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SaferEval_instances, _SaferEval_cache, _SaferEval_maxCacheSize, _SaferEval_shadowParams, _SaferEval_allowGlobals, _SaferEval_enforceAllowlist, _SaferEval_checkAllowlist;
-import * as acorn from "acorn";
-import { containsAwait, extractFreeIdentifiers, extractScopeReads, } from "./analyze.js";
-import { GLOBALS_TO_SHADOW } from "./globals.js";
-import { SaferEvalError, validateNode } from "./validate.js";
-// Compiles and runs the expressions validate.ts approves: parse + analyse once
-// (cached), compile to a Function (AsyncFunction when the expr uses `await`),
-// shadow ambient globals as undefined params, run in-realm so Proxy state works.
-// Guardrail, not a sandbox — see the Expressions docs page, § Safety.
-// Re-exported from validate.ts for callers of this module.
-export { SaferEvalError };
-// The AsyncFunction constructor, for expressions that use `await`.
-const AsyncFunction = Object.getPrototypeOf(async () => { })
-    .constructor;
-export class SaferEval {
-    constructor(options = {}) {
-        _SaferEval_instances.add(this);
-        _SaferEval_cache.set(this, new Map());
-        _SaferEval_maxCacheSize.set(this, void 0);
-        _SaferEval_shadowParams.set(this, void 0);
-        _SaferEval_allowGlobals.set(this, void 0);
-        _SaferEval_enforceAllowlist.set(this, void 0);
-        const { maxCacheSize = 500, extraGlobalsToShadow = [], allowGlobals = [], enforceAllowlist = false, } = options;
-        __classPrivateFieldSet(this, _SaferEval_maxCacheSize, maxCacheSize, "f");
-        __classPrivateFieldSet(this, _SaferEval_enforceAllowlist, enforceAllowlist, "f");
-        const allowSet = new Set(allowGlobals);
-        __classPrivateFieldSet(this, _SaferEval_allowGlobals, allowSet, "f");
-        __classPrivateFieldSet(this, _SaferEval_shadowParams, [...GLOBALS_TO_SHADOW, ...extraGlobalsToShadow].filter((g) => !allowSet.has(g)), "f");
-    }
-    // Parse + validate without running. Throws SaferEvalError if invalid; returns
-    // isAsync + scopeReads and caches the analysis (compile() builds the fn later).
-    validate(expression) {
-        if (typeof expression !== "string") {
-            throw new SaferEvalError("Expression must be a string", "expression-syntax");
-        }
-        const trimmed = expression.trim();
-        if (!trimmed) {
-            throw new SaferEvalError("Expression cannot be empty", "expression-syntax");
-        }
-        const cached = __classPrivateFieldGet(this, _SaferEval_cache, "f").get(expression);
-        if (cached) {
-            return {
-                isAsync: cached.isAsync,
-                scopeReads: cached.scopeReads,
-                freeIds: cached.freeIds,
-            };
-        }
-        // Parse as `"use strict"; void (expr)`: void(...) forces expression context
-        // (so `{...}` is an object literal, not a block), and strict mode rejects
-        // sloppy-only constructs (octal, `with`, dup params) here, not at compile.
-        const wrapper = `"use strict"; void (${trimmed})`;
-        let ast;
-        try {
-            ast = acorn.parse(wrapper, {
-                ecmaVersion: 2022,
-                sourceType: "script",
-                allowAwaitOutsideFunction: true,
-            });
-        }
-        catch (e) {
-            throw new SaferEvalError(`Syntax error: ${e instanceof Error ? e.message : String(e)}. Expression: ${expression}`, "expression-syntax");
-        }
-        validateNode(ast);
-        const analysis = {
-            isAsync: containsAwait(ast),
-            scopeReads: extractScopeReads(ast),
-            freeIds: extractFreeIdentifiers(ast),
-        };
-        // Cache the analysis (no fn yet); evict oldest when full.
-        if (__classPrivateFieldGet(this, _SaferEval_cache, "f").size >= __classPrivateFieldGet(this, _SaferEval_maxCacheSize, "f")) {
-            const firstKey = __classPrivateFieldGet(this, _SaferEval_cache, "f").keys().next().value;
-            if (firstKey !== undefined)
-                __classPrivateFieldGet(this, _SaferEval_cache, "f").delete(firstKey);
-        }
-        __classPrivateFieldGet(this, _SaferEval_cache, "f").set(expression, Object.assign({}, analysis));
-        return analysis;
-    }
-    // Compile to a reusable fn (returns a Promise if the expr uses `await`).
-    compile(expression) {
-        const { isAsync } = this.validate(expression);
-        const entry = __classPrivateFieldGet(this, _SaferEval_cache, "f").get(expression);
-        if (!entry) {
-            // Unreachable — validate() just inserted this entry.
-            throw new SaferEvalError(`Cache entry missing for expression: ${expression}`);
-        }
-        if (entry.fn)
-            return entry.fn;
-        const expr = expression.trim();
-        const Ctor = isAsync ? AsyncFunction : Function;
-        // Single-slot cache: new Ctor bakes in the param names (context keys ∪ shadow
-        // params), so it recompiles only if the context shape changes — which it
-        // doesn't in practice (a given expr always sees the same keys).
-        let cachedSig;
-        let cachedFn;
-        const evaluator = (context) => {
-            const contextKeys = Object.keys(context);
-            const sig = contextKeys.join("\u0000");
-            if (sig !== cachedSig) {
-                // Context keys become params; shadow params follow, bound to undefined.
-                const allParams = [...contextKeys, ...__classPrivateFieldGet(this, _SaferEval_shadowParams, "f")];
-                try {
-                    cachedFn = new Ctor(...allParams, `"use strict"; return (${expr})`);
-                }
-                catch (e) {
-                    // Parsed but won't compile — surface as SaferEvalError, not a raw one.
-                    throw new SaferEvalError(`Failed to compile expression: ${e instanceof Error ? e.message : String(e)}. Expression: ${expression}`, "expression-syntax");
-                }
-                cachedSig = sig;
-            }
-            // Args match allParams: context values (Object.keys order) then shadow fills.
-            const allArgs = [
-                ...Object.values(context),
-                ...new Array(__classPrivateFieldGet(this, _SaferEval_shadowParams, "f").length).fill(undefined),
-            ];
-            return cachedFn(...allArgs);
-        };
-        entry.fn = evaluator;
-        return evaluator;
-    }
-    isAsync(expression) {
-        const cached = __classPrivateFieldGet(this, _SaferEval_cache, "f").get(expression);
-        if (cached)
-            return cached.isAsync;
-        return this.validate(expression).isAsync;
-    }
-    // Every `scopes.X.Y` path the expression reads — the renderer auto-subscribes
-    // to these instead of the LLM writing a deps array.
-    scopeReads(expression) {
-        const cached = __classPrivateFieldGet(this, _SaferEval_cache, "f").get(expression);
-        if (cached)
-            return cached.scopeReads;
-        return this.validate(expression).scopeReads;
-    }
-    eval(expression, context = {}, allowedGlobals = []) {
-        if (__classPrivateFieldGet(this, _SaferEval_enforceAllowlist, "f")) {
-            const { freeIds } = this.validate(expression);
-            __classPrivateFieldGet(this, _SaferEval_instances, "m", _SaferEval_checkAllowlist).call(this, freeIds, Object.keys(context), allowedGlobals);
-        }
-        const evaluator = this.compile(expression);
-        return evaluator(context);
-    }
-    clearCache() {
-        __classPrivateFieldGet(this, _SaferEval_cache, "f").clear();
-    }
-}
-_SaferEval_cache = new WeakMap(), _SaferEval_maxCacheSize = new WeakMap(), _SaferEval_shadowParams = new WeakMap(), _SaferEval_allowGlobals = new WeakMap(), _SaferEval_enforceAllowlist = new WeakMap(), _SaferEval_instances = new WeakSet(), _SaferEval_checkAllowlist = function _SaferEval_checkAllowlist(freeIds, contextKeys, allowedGlobals) {
-    const allowed = new Set([
-        ...contextKeys,
-        ...__classPrivateFieldGet(this, _SaferEval_allowGlobals, "f"),
-        ...allowedGlobals,
-    ]);
-    for (const id of freeIds) {
-        if (!allowed.has(id)) {
-            // The expression named something that doesn't exist here — an
-            // unregistered function or a global outside the allowlist.
-            throw new SaferEvalError(`"${id}" is not available in expressions`, "unknown-reference");
-        }
-    }
-};

package/dist/expr/validate.d.ts

@@ -1,7 +0,0 @@
-import type * as acorn from "acorn";
-export type SaferEvalErrorReason = "expression-syntax" | "sandbox-violation" | "unknown-reference";
-export declare class SaferEvalError extends Error {
-    readonly reason: SaferEvalErrorReason;
-    constructor(message: string, reason?: SaferEvalErrorReason);
-}
-export declare function validateNode(node: acorn.AnyNode | null | undefined, insideFunctionBody?: boolean): void;

package/dist/expr/validate.js

@@ -1,109 +0,0 @@
-import { isNode } from "./ast-utils.js";
-export class SaferEvalError extends Error {
-    constructor(message, reason = "sandbox-violation") {
-        super(message);
-        this.name = "SaferEvalError";
-        this.reason = reason;
-    }
-}
-// `eval` / `arguments` can't be shadowed as strict-mode params, so reject them as
-// references here instead (the rest are shadowed — see GLOBALS_TO_SHADOW).
-const FORBIDDEN_IDENTIFIERS = new Set(["eval", "arguments"]);
-// Most dangerous syntax never reaches this walk: every expression is parsed as
-// `"use strict"; void (EXPR)`, so a top-level statement / declaration / `with` /
-// octal / import is a syntax error. What survives, to reject by hand, is below.
-// Forbidden everywhere, even in a function body: dynamic `import()` loads code,
-// and `import.meta` / `new.target` (MetaProperty) reach host / constructor
-// internals. Keywords, so shadowing can't touch them — block structurally.
-const FORBIDDEN_EXPRESSIONS = new Set(["ImportExpression", "MetaProperty"]);
-// Forbidden as the whole expression (which must be one pure value); fine inside a
-// callback body where imperative code is allowed.
-const BODY_ONLY_EXPRESSIONS = new Set([
-    "AssignmentExpression", // x = 1, x += 1
-    "UpdateExpression", // x++, --x
-    "SequenceExpression", // a, b — comma operator
-]);
-// Escape-hatch property names: `.constructor` reaches the Function constructor,
-// `.__proto__` the prototype chain. Only static keys are caught; a computed key
-// escapes (the guardrail gap — banning it would ban all `arr[i]` access).
-const FORBIDDEN_PROPERTIES = new Set([
-    "constructor",
-    "__proto__",
-    "prototype",
-    "__defineGetter__",
-    "__defineSetter__",
-    "__lookupGetter__",
-    "__lookupSetter__",
-]);
-// Recursively walk the parsed expression, throwing on anything disallowed.
-// insideFunctionBody flips once inside an arrow / function body, where the
-// BODY_ONLY_EXPRESSIONS become legal. Entry point is acorn's Program node.
-export function validateNode(node, insideFunctionBody = false) {
-    if (!node || typeof node !== "object")
-        return;
-    // The wrapped program must hold exactly one expression (the filter drops the
-    // "use strict" directive). More than one means the expr smuggled a `)` to break
-    // out of `void (...)` — e.g. `1); evil(); (2`.
-    if (node.type === "Program") {
-        const statements = node.body.filter((s) => !(s.type === "ExpressionStatement" && s.directive));
-        if (statements.length !== 1) {
-            throw new SaferEvalError(`Expression must be a single expression, got ${statements.length} statements`);
-        }
-        validateNode(statements[0]);
-        return;
-    }
-    // Dynamic import / meta-properties: never allowed, not even in a body.
-    if (FORBIDDEN_EXPRESSIONS.has(node.type)) {
-        throw new SaferEvalError(`"${node.type}" is not allowed in expressions`);
-    }
-    // Assignment / update / comma: allowed in a callback body, not as the whole expr.
-    if (BODY_ONLY_EXPRESSIONS.has(node.type) && !insideFunctionBody) {
-        throw new SaferEvalError(`"${node.type}" is only allowed inside a function body, not as the whole expression`);
-    }
-    // Tagged templates invoke an arbitrary tag function.
-    if (node.type === "TaggedTemplateExpression") {
-        throw new SaferEvalError("Tagged template literals are not allowed");
-    }
-    // Static access to escape-hatch properties; dynamic keys slip past.
-    if (node.type === "MemberExpression") {
-        const { property, computed } = node;
-        const staticKey = !computed && property.type === "Identifier"
-            ? property.name
-            : computed &&
-                property.type === "Literal" &&
-                typeof property.value === "string"
-                ? property.value
-                : null;
-        if (staticKey !== null && FORBIDDEN_PROPERTIES.has(staticKey)) {
-            throw new SaferEvalError(`Access to "${staticKey}" is not allowed`);
-        }
-    }
-    // `eval` / `arguments` in reference position (the recursion below skips a
-    // non-computed member's `.property`, so a harmless `row.arguments` isn't hit).
-    if (node.type === "Identifier" && FORBIDDEN_IDENTIFIERS.has(node.name)) {
-        throw new SaferEvalError(`Access to "${node.name}" is not allowed`);
-    }
-    // Recurse. Two carries: descending into a function `body` sets
-    // insideFunctionBody for the subtree; a non-computed member's `.property` is a
-    // name already checked, so skip it (a computed `obj[eval]` is not skipped).
-    const fields = node;
-    const isFunction = node.type === "ArrowFunctionExpression" ||
-        node.type === "FunctionExpression";
-    for (const key of Object.keys(node)) {
-        if (key === "type" || key === "start" || key === "end")
-            continue;
-        if (node.type === "MemberExpression" && !node.computed && key === "property")
-            continue;
-        const child = fields[key];
-        const childInside = insideFunctionBody || (isFunction && key === "body");
-        if (Array.isArray(child)) {
-            for (const c of child) {
-                if (isNode(c))
-                    validateNode(c, childInside);
-            }
-        }
-        else if (isNode(child)) {
-            validateNode(child, childInside);
-        }
-    }
-}