monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/analysis/lib/partial.js

@@ -0,0 +1,518 @@
+// Patch shape (§5 Partially resolved writes): whether a write site whose holder the analyzer can't resolve keeps the
+// original of the slot it writes, so that it may patch a native. A site keeps it when it reads the same (holder,
+// member) first, in the same function, and that read is:
+//
+// - called, or `.call`/`.apply`/`.bind`-ed
+// - passed to a call whose callee isn't a catalog native (`wrap(o.fetch)`, not `String(o.fetch)`)
+// - stored: a variable's initializer, an assignment's value, an object literal's field or an array element
+// - kept when present: `o.m = o.m || p`, `o.m ||= p`, `if (!o.m) o.m = p`, `o.m || (o.m = p)`
+//
+// A define also counts when its descriptor gives `get` or `set`, or when a `getOwnPropertyDescriptor` of the same slot
+// comes before it. A delete counts only after the original was captured, by such a read or a descriptor read.
+//
+// The same (holder, member) is the same root variable, parameter or `this`, through the same constant property chain
+// after aliases, with no redefinition of a root variable between the read and the write. A holder chosen by `?:`,
+// `&&`, `||` or `??` among such expressions is the same when every part is.
+import { calleeExpression, walkTree } from "./ast.js";
+import { literalKey } from "./keys.js";
+/** Functions, whose own code is apart from the code around them. */
+const functionTypes = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
+export function slotSignatures(context) {
+    /** The constant key a member expression reads: its name, or a computed key that folds. */
+    const keyOf = (member) => {
+        const property = member['property'];
+        if (member['computed'] === true)
+            return context.fold(property);
+        return property.type === 'Identifier' ? property['name'] : undefined;
+    };
+    /** The variable an identifier names, followed through aliases that have one definition, a plain name or member. */
+    const rooted = (id, roots, depth) => {
+        const key = context.definitions.keyOf(id);
+        if (key === undefined)
+            return undefined;
+        const definitions = context.definitions.of(key);
+        const [only] = definitions;
+        if (definitions.length === 1 &&
+            only?.site.type === 'VariableDeclarator' &&
+            only.pattern.type === 'Identifier' &&
+            only.source !== undefined) {
+            const source = unwrapped(only.source);
+            if (source.type === 'Identifier' || source.type === 'MemberExpression' || source.type === 'ThisExpression') {
+                // An alias past the cap is taken as the root, a hit of the cap (§18).
+                if (depth >= context.aliasDepth)
+                    context.aliasCut(id);
+                else {
+                    const followed = signature(source, roots, depth + 1);
+                    if (followed !== undefined)
+                        return followed;
+                }
+            }
+        }
+        roots.push(key);
+        return `v(${key.scope === 'global' ? 'global' : key.scope.start}:${key.name})`;
+    };
+    /**
+     * A holder expression's signature, the same for two expressions that give the same holder, with the variables it
+     * reads in `roots`; none when it is no such expression (a call, a literal).
+     */
+    const signature = (expression, roots, depth = 0) => {
+        const node = unwrapped(expression);
+        switch (node.type) {
+            case 'Identifier':
+                return rooted(node, roots, depth);
+            case 'ThisExpression':
+                return 'this';
+            case 'MemberExpression': {
+                const object = signature(node['object'], roots, depth);
+                const key = keyOf(node);
+                return object === undefined || key === undefined ? undefined : `m(${object},${keySignature(key)})`;
+            }
+            case 'ConditionalExpression': {
+                const parts = ['test', 'consequent', 'alternate'].map((part) => signature(node[part], roots, depth));
+                return parts.every((part) => part !== undefined) ? `c(${parts.join(',')})` : undefined;
+            }
+            case 'LogicalExpression': {
+                const parts = ['left', 'right'].map((part) => signature(node[part], roots, depth));
+                return parts.every((part) => part !== undefined) ? `l${node['operator']}(${parts.join(',')})` : undefined;
+            }
+            default:
+                return undefined;
+        }
+    };
+    /** Whether a root variable is defined again between `from` and `to`. */
+    const redefined = (roots, from, to) => roots.some((key) => context.definitions.of(key).some(({ site }) => site.start >= from && site.start < to));
+    /** A key expression's signature (`Slots.keySignature`). */
+    const keyExpression = (expression, roots) => {
+        const node = unwrapped(expression);
+        switch (node.type) {
+            case 'Literal': {
+                const literal = literalKey(node);
+                return literal === undefined ? undefined : keySignature(literal);
+            }
+            case 'Identifier':
+                return rooted(node, roots, 0);
+            case 'ThisExpression':
+                return 'this';
+            case 'MemberExpression': {
+                const object = keyExpression(node['object'], roots);
+                const property = node['property'];
+                const key = node['computed'] === true
+                    ? keyExpression(property, roots)
+                    : property.type === 'Identifier'
+                        ? JSON.stringify(property['name'])
+                        : undefined;
+                return object === undefined || key === undefined ? undefined : `m(${object},${key})`;
+            }
+            // A key built from such parts by `+` or a template, as a prefix and a name (`"get" + k`).
+            case 'BinaryExpression': {
+                if (node['operator'] !== '+')
+                    return undefined;
+                const parts = ['left', 'right'].map((part) => keyExpression(node[part], roots));
+                return parts.every((part) => part !== undefined) ? `+(${parts.join(',')})` : undefined;
+            }
+            case 'TemplateLiteral': {
+                const quasis = node['quasis'].map((quasi) => quasi['value'].cooked);
+                const expressions = node['expressions'].map((each) => keyExpression(each, roots));
+                if (quasis.some((cooked) => cooked === null) || expressions.some((each) => each === undefined))
+                    return undefined;
+                return `t(${JSON.stringify(quasis)},${expressions.join(',')})`;
+            }
+            default:
+                return undefined;
+        }
+    };
+    return { signature: (expression, roots) => signature(expression, roots), keySignature: keyExpression, redefined };
+}
+/** Patch-shape and key-reuse judgements over one program: its parents, computed once. */
+export function patchShapes(context) {
+    /** The constant key a member expression reads: its name, or a computed key that folds. */
+    const keyOf = (member) => {
+        const property = member['property'];
+        if (member['computed'] === true)
+            return context.fold(property);
+        return property.type === 'Identifier' ? property['name'] : undefined;
+    };
+    const { signature, keySignature: keyExpression, redefined } = slotSignatures(context);
+    let parents;
+    const parentOf = (node) => {
+        if (parents === undefined) {
+            const built = new Map();
+            walkTree(context.program, {
+                enter(child, parent) {
+                    if (parent !== null)
+                        built.set(child, parent);
+                },
+            });
+            parents = built;
+        }
+        return parents.get(node);
+    };
+    /** The function (or the program) whose own code a node is in. */
+    const ownerOf = (node) => {
+        let at = parentOf(node);
+        while (at !== undefined && !functionTypes.has(at.type))
+            at = parentOf(at);
+        return at ?? context.program;
+    };
+    /** The member expressions and calls in `owner`'s own code, nested functions left out, in document order. */
+    const members = new Map();
+    const membersOf = (owner) => {
+        const cached = members.get(owner);
+        if (cached !== undefined)
+            return cached;
+        const found = [];
+        walkTree(owner, {
+            enter(node) {
+                if (node !== owner && functionTypes.has(node.type))
+                    return false;
+                if (node.type === 'MemberExpression' || node.type === 'CallExpression')
+                    found.push(node);
+                else if (node.type === 'BinaryExpression' && node['operator'] === 'in')
+                    found.push(node);
+            },
+        });
+        members.set(owner, found);
+        return found;
+    };
+    /**
+     * The expression a value's use is judged at: past the parentheses, optional chains, `?:` arms, the last expression
+     * of a comma sequence and the operands of `&&`, `||` and `??` it sits in. `present` says it passed the left of an
+     * `||` or `??`, which keeps it when present.
+     */
+    const useOf = (node) => {
+        let use = node;
+        let present = false;
+        for (;;) {
+            const parent = parentOf(use);
+            if (parent === undefined)
+                return { use, parent, present };
+            const transparent = parent.type === 'ParenthesizedExpression' ||
+                parent.type === 'ChainExpression' ||
+                (parent.type === 'ConditionalExpression' && parent['test'] !== use) ||
+                (parent.type === 'SequenceExpression' && parent['expressions'].at(-1) === use) ||
+                parent.type === 'LogicalExpression';
+            if (!transparent)
+                return { use, parent, present };
+            if (parent.type === 'LogicalExpression' && parent['left'] === use && parent['operator'] !== '&&')
+                present = true;
+            use = parent;
+        }
+    };
+    /** Whether `node` lies within `outer`. */
+    const within = (node, outer) => node.start >= outer.start && node.end <= outer.end;
+    /** Whether a read of the original, `read`, keeps it for the write `write`. */
+    const keeps = (read, write) => {
+        const { use, parent, present } = useOf(read);
+        if (parent === undefined)
+            return false;
+        // Kept when present: `o.m = o.m || p`.
+        if (parent === write.site && use === write.value && present)
+            return true;
+        // Tested before the write: `if (!o.m) o.m = p`, `o.m || (o.m = p)`, `o.m ? … : (o.m = p)`.
+        if (testedBefore(read, write.site))
+            return true;
+        switch (parent.type) {
+            case 'CallExpression':
+            case 'NewExpression':
+                if (parent['callee'] === use)
+                    return true;
+                return parent['arguments'].includes(use) && !context.isCatalogNative(parent['callee']);
+            case 'MemberExpression': {
+                if (parent['object'] !== use)
+                    return false;
+                const key = keyOf(parent);
+                return key === 'call' || key === 'apply' || key === 'bind';
+            }
+            case 'VariableDeclarator':
+                return parent['init'] === use;
+            case 'AssignmentExpression':
+                // The write's own value is no store: `o.m = o.m` writes it back.
+                return parent['right'] === use && parent !== write.site;
+            case 'Property':
+                // A bulk mechanism's own field is no store: `Object.assign(o, { m: o.m })` writes it back.
+                return parent['value'] === use && parent !== write.site && parentOf(parent)?.type === 'ObjectExpression';
+            case 'ArrayExpression':
+                return true;
+            default:
+                return false;
+        }
+    };
+    /**
+     * Whether `read` is tested for presence so that `site` runs only when the original is absent, which keeps it when
+     * present: the read itself, negated, its `typeof` compared with a string, or the read compared with `null`,
+     * `undefined`, `void` or a string, as the test of an `if` or `?:` with `site` in the arm that runs when it is absent,
+     * or as the left of `&&`, `||` or `??` with `site` on the right (`if (!o.m) o.m = p`, `o.m || (o.m = p)`, not
+     * `if (o.m) o.m = p` nor `o.m && (o.m = p)`). Parts of a test joined by `&&` or `||` carry what they imply.
+     */
+    const testedBefore = (read, site) => {
+        // What the value at `child` being truthy, or falsy, says of the original, and what that value is: the read itself,
+        // its `typeof`, or a boolean derived from it.
+        let sense = { truthy: 'present', falsy: 'absent' };
+        let mode = 'read';
+        for (let child = read, at = parentOf(read); at !== undefined; child = at, at = parentOf(at)) {
+            switch (at.type) {
+                case 'ParenthesizedExpression':
+                case 'ChainExpression':
+                    continue;
+                case 'UnaryExpression':
+                    if (mode === 'read' && at['operator'] === 'typeof')
+                        mode = 'typeof';
+                    else if (mode !== 'typeof' && at['operator'] === '!') {
+                        sense = { truthy: sense.falsy, falsy: sense.truthy };
+                        mode = 'boolean';
+                    }
+                    else
+                        return false;
+                    continue;
+                case 'BinaryExpression': {
+                    if (mode === 'boolean')
+                        return false;
+                    const compared = comparison(at, child, mode);
+                    if (compared === undefined)
+                        return false;
+                    sense = compared;
+                    mode = 'boolean';
+                    continue;
+                }
+                case 'LogicalExpression': {
+                    if (mode === 'typeof')
+                        return false;
+                    const operator = at['operator'];
+                    if (at['left'] === child && within(site, at['right'])) {
+                        if (operator === '&&')
+                            return sense.truthy === 'absent';
+                        if (operator === '||')
+                            return sense.falsy === 'absent';
+                        return mode === 'read';
+                    }
+                    // A part of a larger test: the whole being truthy says each part of an `&&` is, and falsy each part of an `||`.
+                    if (operator === '&&')
+                        sense = { truthy: sense.truthy, falsy: undefined };
+                    else if (operator === '||')
+                        sense = { truthy: undefined, falsy: sense.falsy };
+                    else
+                        return false;
+                    mode = 'boolean';
+                    continue;
+                }
+                case 'IfStatement':
+                case 'ConditionalExpression': {
+                    if (at['test'] !== child || mode === 'typeof')
+                        return false;
+                    const [consequent, alternate] = [at['consequent'], at['alternate']];
+                    if (consequent != null && within(site, consequent))
+                        return sense.truthy === 'absent';
+                    if (alternate != null && within(site, alternate))
+                        return sense.falsy === 'absent';
+                    return false;
+                }
+                default:
+                    return false;
+            }
+        }
+        return false;
+    };
+    const patchShaped = (write) => {
+        const roots = [];
+        const holder = signature(write.holder, roots);
+        if (holder === undefined)
+            return false;
+        const slot = `m(${holder},${keySignature(write.change.member)})`;
+        const change = write.change;
+        if (change.kind === 'define' && (change.descriptor.get || change.descriptor.set))
+            return true;
+        const owner = ownerOf(write.site);
+        for (const node of membersOf(owner)) {
+            // Only what comes before the write, or is part of it, counts, and never the member expression written.
+            if (node.start >= write.site.end || node === write.target)
+                continue;
+            if (write.target !== undefined && within(node, write.target))
+                continue;
+            if (redefined(roots, node.end, write.site.start))
+                continue;
+            if (node.type === 'BinaryExpression')
+                continue;
+            if (node.type === 'CallExpression') {
+                // A descriptor read of the same slot captures the original for a define or a delete.
+                if (change.kind === 'set' || !context.isDescriptorReader(calleeExpression(node['callee'])))
+                    continue;
+                const [object, key] = node['arguments'];
+                if (object === undefined || key === undefined || node.end > write.site.start)
+                    continue;
+                const readRoots = [];
+                const read = signature(object, readRoots);
+                const member = context.fold(key);
+                if (read === holder && member !== undefined && keySignature(member) === keySignature(change.member))
+                    return true;
+                continue;
+            }
+            const readRoots = [];
+            const object = signature(node['object'], readRoots);
+            const key = keyOf(node);
+            if (object === undefined || key === undefined || `m(${object},${keySignature(key)})` !== slot)
+                continue;
+            if (keeps(node, write))
+                return true;
+        }
+        return write.keepsPresent === true;
+    };
+    /**
+     * Whether a function reads the slot of its `index`th parameter, as a key, from the holder `holder` signs: through
+     * another parameter whose argument in `args` gives that holder, or through an expression that gives it.
+     */
+    const readsParameter = (fn, index, args, holder) => {
+        const params = fn['params'];
+        /** The parameter an identifier in the function's own code reads, by its index; -1 for none. */
+        const parameterOf = (id) => {
+            const variable = context.definitions.keyOf(id);
+            if (variable?.scope !== fn)
+                return -1;
+            return params.findIndex((param) => param.type === 'Identifier' && param['name'] === variable.name);
+        };
+        if (params[index]?.type !== 'Identifier')
+            return false;
+        return membersOf(fn).some((node) => {
+            if (node.type !== 'MemberExpression' || node['computed'] !== true)
+                return false;
+            const property = unwrapped(node['property']);
+            if (property.type !== 'Identifier' || parameterOf(property) !== index)
+                return false;
+            const object = unwrapped(node['object']);
+            const at = object.type === 'Identifier' ? parameterOf(object) : -1;
+            const arg = at < 0 ? undefined : args[at];
+            if (at >= 0)
+                return arg !== undefined && arg.type !== 'SpreadElement' && signature(arg, []) === holder;
+            return signature(object, []) === holder;
+        });
+    };
+    const reuse = (write) => {
+        const roots = [];
+        const holder = signature(write.object, roots);
+        const key = holder === undefined ? undefined : keyExpression(write.key, roots);
+        if (holder === undefined || key === undefined)
+            return undefined;
+        const slot = `m(${holder},${key})`;
+        const signs = (object, member) => {
+            if (member === undefined || signature(object, []) !== holder)
+                return false;
+            return keyExpression(member, []) === key;
+        };
+        /** The key a member expression reads, signed as `keyExpression` signs it. */
+        const memberKey = (member) => {
+            const property = member['property'];
+            if (member['computed'] === true)
+                return keyExpression(property, []);
+            return property.type === 'Identifier' ? JSON.stringify(property['name']) : undefined;
+        };
+        const reads = new Set();
+        const descriptors = new Set();
+        let keptWhenPresent = write.keepsPresent === true;
+        const owner = ownerOf(write.site);
+        for (const node of membersOf(owner)) {
+            // Only what comes before the write, or is part of it, counts, and never the member expression written.
+            if (node.start >= write.site.end || node === write.target)
+                continue;
+            if (write.target !== undefined && within(node, write.target))
+                continue;
+            if (redefined(roots, node.end, write.site.start))
+                continue;
+            if (node.type === 'BinaryExpression') {
+                // `k in o` tests presence: the write keeps the member when it runs only on its absence.
+                if (signs(node['right'], node['left']) && testedBefore(node, write.site))
+                    keptWhenPresent = true;
+                continue;
+            }
+            if (node.type === 'CallExpression') {
+                if (node.end > write.site.start)
+                    continue;
+                const args = node['arguments'];
+                const callee = calleeExpression(node['callee']);
+                if (context.isDescriptorReader(callee)) {
+                    if (signs(args[0], args[1]))
+                        descriptors.add(node);
+                    continue;
+                }
+                // A read in a summarized callee whose parameter is bound to the same key binding.
+                const index = args.findIndex((arg) => arg.type !== 'SpreadElement' && keyExpression(arg, []) === key);
+                if (index < 0)
+                    continue;
+                if (context.calleeFunctions(callee).some((fn) => readsParameter(fn, index, args, holder)))
+                    reads.add(node);
+                continue;
+            }
+            const object = signature(node['object'], []);
+            const member = memberKey(node);
+            if (object === undefined || member === undefined || `m(${object},${member})` !== slot)
+                continue;
+            reads.add(node);
+            const { use, parent, present } = useOf(node);
+            if ((parent === write.site && use === write.value && present) || testedBefore(node, write.site))
+                keptWhenPresent = true;
+        }
+        if (reads.size === 0 && descriptors.size === 0 && !keptWhenPresent)
+            return undefined;
+        const value = write.value === undefined ? undefined : unwrapped(write.value);
+        const writesBack = value !== undefined && value.type === 'MemberExpression' && reads.has(value);
+        /** Whether an expression gives a descriptor fetched from the slot: the call, or a variable it alone defines. */
+        const fetched = (node) => {
+            const expression = unwrapped(node);
+            if (descriptors.has(expression))
+                return true;
+            if (expression.type !== 'Identifier')
+                return false;
+            const variable = context.definitions.keyOf(expression);
+            const definitions = variable === undefined ? [] : context.definitions.of(variable);
+            return (definitions.length > 0 &&
+                definitions.every((each) => each.source !== undefined && descriptors.has(unwrapped(each.source))));
+        };
+        const isOriginal = (node) => {
+            const expression = unwrapped(node);
+            if (reads.has(expression))
+                return true;
+            if (expression.type !== 'MemberExpression' || expression['computed'] === true)
+                return false;
+            const property = expression['property'];
+            return property.type === 'Identifier' && property['name'] === 'value' && fetched(expression['object']);
+        };
+        return { isOriginal, keptWhenPresent, writesBack };
+    };
+    return { patchShaped, reuse };
+}
+/** The operators that compare a value with `null`, `undefined` or a string. */
+const equalities = new Set(['==', '!=', '===', '!==']);
+/**
+ * What a comparison of `child` (the read, or its `typeof`) says of the original: with `null`, `undefined` or `void`,
+ * that it is absent or present; with a string, the read's `typeof` equal to `'undefined'` that it is absent, and any
+ * other string equal that it is present. None for any other comparison.
+ */
+function comparison(node, child, mode) {
+    const operator = node['operator'];
+    if (!equalities.has(operator))
+        return undefined;
+    const other = (node['left'] === child ? node['right'] : node['left']);
+    const nullish = (other.type === 'Literal' && other['value'] === null && other['raw'] === 'null') ||
+        (other.type === 'Identifier' && other['name'] === 'undefined') ||
+        (other.type === 'UnaryExpression' && other['operator'] === 'void');
+    const string = other.type === 'Literal' && typeof other['value'] === 'string' ? other['value'] : undefined;
+    let equal;
+    if (mode === 'read' && nullish)
+        equal = { truthy: 'absent', falsy: 'present' };
+    else if (string === undefined)
+        return undefined;
+    else if (mode === 'typeof' && string === 'undefined')
+        equal = { truthy: 'absent', falsy: 'present' };
+    else
+        equal = { truthy: 'present', falsy: undefined };
+    return operator.startsWith('!') ? { truthy: equal.falsy, falsy: equal.truthy } : equal;
+}
+/** A key's signature: a string's JSON, or a well-known symbol's description. */
+function keySignature(key) {
+    return typeof key === 'symbol' ? `s:${key.description ?? ''}` : JSON.stringify(key);
+}
+/** An expression past its parentheses and optional chain. */
+function unwrapped(node) {
+    let at = node;
+    while (at.type === 'ParenthesizedExpression' || at.type === 'ChainExpression')
+        at = at['expression'];
+    return at;
+}

package/dist/packages/analysis/lib/print.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from './ast.ts';
+/** An expression printed from its syntax, cut at 120 characters. */
+export declare function printed(node: AstNode): string;

package/dist/packages/analysis/lib/print.js

@@ -0,0 +1,150 @@
+// Expressions as a trace shows them (§14): printed from the syntax, so code nested in a string literal (§2) prints as
+// the code it is, and cut to a short line.
+/** How long a printed expression may be. A longer one is cut, and ends in an ellipsis. */
+const maxLength = 120;
+/** An expression printed from its syntax, cut at 120 characters. */
+export function printed(node) {
+    const text = print(node);
+    return text.length > maxLength ? `${text.slice(0, maxLength - 1)}…` : text;
+}
+/** Operators written as words, which need a space before their operand. */
+const wordOperators = new Set(['typeof', 'void', 'delete']);
+/** Expressions that bind less tightly than any operand, so an operand of one of them is parenthesized. */
+const loose = new Set([
+    'LogicalExpression',
+    'ConditionalExpression',
+    'SequenceExpression',
+    'AssignmentExpression',
+    'ArrowFunctionExpression',
+    'YieldExpression',
+]);
+function print(node) {
+    switch (node.type) {
+        case 'Literal':
+            return literal(node);
+        case 'TemplateLiteral': {
+            const quasis = node['quasis'].map((quasi) => quasi['value'].raw);
+            const expressions = node['expressions'];
+            return `\`${quasis.map((quasi, index) => (index < expressions.length ? `${quasi}\${${print(expressions[index])}}` : quasi)).join('')}\``;
+        }
+        case 'Identifier':
+            return node['name'];
+        case 'PrivateIdentifier':
+            return `#${node['name']}`;
+        case 'ThisExpression':
+            return 'this';
+        case 'Super':
+            return 'super';
+        case 'BinaryExpression':
+        case 'LogicalExpression': {
+            // A left operand with the same operator groups the way it is written: `"a" + "b" + "c"`. The chain is printed from
+            // a list rather than by recursion, because minified code builds long ones, and only up to a trace line.
+            const operator = node['operator'];
+            const rights = [];
+            let left = node;
+            while (left.type === node.type && left['operator'] === operator) {
+                rights.push(left['right']);
+                left = left['left'];
+            }
+            let text = operand(left, false);
+            for (const right of rights.reverse()) {
+                if (text.length > maxLength)
+                    break;
+                text += ` ${operator} ${operand(right, false)}`;
+            }
+            return text;
+        }
+        case 'UnaryExpression': {
+            const operator = node['operator'];
+            const argument = operand(node['argument'], false);
+            return wordOperators.has(operator) ? `${operator} ${argument}` : `${operator}${argument}`;
+        }
+        case 'ConditionalExpression':
+            return `${operand(node['test'], false)} ? ${print(node['consequent'])} : ${print(node['alternate'])}`;
+        case 'SequenceExpression':
+            return `(${list(node['expressions'])})`;
+        case 'AssignmentExpression':
+            return `${print(node['left'])} ${node['operator']} ${print(node['right'])}`;
+        case 'AssignmentPattern':
+            return `${print(node['left'])} = ${print(node['right'])}`;
+        case 'MemberExpression': {
+            const object = operand(node['object'], false);
+            const property = node['property'];
+            const optional = node['optional'] === true ? '?.' : '';
+            if (node['computed'] === true)
+                return `${object}${optional}[${print(property)}]`;
+            return `${object}${optional === '' ? '.' : optional}${print(property)}`;
+        }
+        case 'ChainExpression':
+            return print(node['expression']);
+        case 'CallExpression':
+            return `${operand(node['callee'], false)}(${list(node['arguments'])})`;
+        case 'NewExpression':
+            return `new ${operand(node['callee'], false)}(${list(node['arguments'])})`;
+        case 'ArrayExpression':
+            return `[${list(node['elements'])}]`;
+        case 'ObjectExpression':
+            return node['properties'].length === 0 ? '{}' : '{…}';
+        case 'SpreadElement':
+        case 'RestElement':
+            return `...${print(node['argument'])}`;
+        case 'VariableDeclarator': {
+            // A definition (§14 `alias`): the declarator's pattern and its initializer.
+            const init = node['init'];
+            return init === null ? print(node['id']) : `${print(node['id'])} = ${print(init)}`;
+        }
+        case 'VariableDeclaration':
+            return `${node['kind']} ${list(node['declarations'])}`;
+        case 'UpdateExpression': {
+            const argument = print(node['argument']);
+            const operator = node['operator'];
+            return node['prefix'] === true ? `${operator}${argument}` : `${argument}${operator}`;
+        }
+        case 'ForInStatement':
+        case 'ForOfStatement':
+            return `for (${print(node['left'])} ${node.type === 'ForInStatement' ? 'in' : 'of'} ${print(node['right'])})`;
+        case 'ObjectPattern':
+            return `{ ${list(node['properties'])} }`;
+        case 'ArrayPattern':
+            return `[${list(node['elements'])}]`;
+        case 'Property': {
+            const key = node['key'];
+            const value = print(node['value']);
+            if (node['shorthand'] === true)
+                return value;
+            return `${node['computed'] === true ? `[${print(key)}]` : print(key)}: ${value}`;
+        }
+        default:
+            return '…';
+    }
+}
+/** An operand, parenthesized when it binds less tightly than the expression it is in. */
+function operand(node, tight) {
+    const text = print(node);
+    const parenthesized = loose.has(node.type) || (!tight && node.type === 'BinaryExpression');
+    return parenthesized ? `(${text})` : text;
+}
+/** A comma-separated list, with holes left empty, that stops once it is longer than a trace line. */
+function list(nodes) {
+    let text = '';
+    for (const [index, node] of nodes.entries()) {
+        if (index > 0)
+            text += ', ';
+        if (text.length > maxLength)
+            return `${text}…`;
+        if (node !== null)
+            text += print(node);
+    }
+    return text;
+}
+function literal(node) {
+    const regex = node['regex'];
+    if (regex !== null && regex !== undefined)
+        return `/${regex.pattern}/${regex.flags}`;
+    const bigint = node['bigint'];
+    if (bigint !== null && bigint !== undefined)
+        return `${bigint}n`;
+    const value = node['value'];
+    // A long string is cut before it is quoted, so a trace never copies a huge literal.
+    return typeof value === 'string' ? JSON.stringify(value.length > maxLength ? value.slice(0, maxLength) : value) : String(value);
+}