monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/analysis/lib/module-links.js

@@ -0,0 +1,1060 @@
+// Module links inside one artifact (§6, ADR 0003): the webpack shapes of the module-linking idioms, and, in
+// `hoistedLinks` below, the shapes esbuild, Rollup and Rolldown emit (memoized getters, lazy module thunks, their getter
+// export definers and interop wrappers).
+//
+// - **Factory table + require**: an object or array literal of factories keyed by constant id (webpack 5 object
+//   tables, webpack 4-style arrays), read by a require function, a function whose own code calls `T[id](…)` or
+//   `T[id].call(…)` with its first parameter as the key and passes itself on. The require is that function, and the
+//   parameter each factory takes it as (its third).
+// - **Getter export definer**: `R.d(exports, { x: () => l })`, its array form `R.d(exports, ["x", () => l, "y", 0, v])`
+//   (a `0` marks a value), and the older `R.d(exports, "x", () => l)`, where `R` is the require.
+// - **Interop wrappers**: `R.n(m)` and `R.cw(factory)`. `R.cw`'s thunk is also a lazy module thunk, which `hoistedLinks`
+//   recognizes by its shape (below), so each `var x = R.cw(factory)` is a module.
+//
+// Links are recovered from structure, never from knowing which bundler produced the code. The require and the table are
+// followed by the evaluator's general call and heap semantics: a require call runs its factory through the table's
+// computed read. The definer is modeled here: each of its calls defines its exports' fields, getters or values, and
+// the defines the definer's own body makes are left to the model. What comes through a definer's export carries a
+// `module-link` fold (§14), with its module's id and the export's name. Module ids are build-local, so they appear only
+// in the trace, never in identity (§6).
+//
+// A require call whose id isn't a constant, or names no factory in the table, is a broken link (§6 Degradation). A call
+// through what a broken link returns (`R(id)(…)`, `R(id).x(…)`, `m.x(…)` with `m = R(id)`) is an unlinked module call.
+// An unrecognized runtime looks like ordinary code, and gives nothing here.
+import { calleeExpression, walkTree } from "./ast.js";
+import { shadowedNameOf } from "./definitions.js";
+import { registriesOf } from "./chunk-registry.js";
+import { literalKey } from "./keys.js";
+const none = {
+    idioms: new Set(),
+    tables: false,
+    modules: 0,
+    defines: [],
+    definers: new Set(),
+    links: new Map(),
+    firsts: new Map(),
+    factories: new Map(),
+    broken: [],
+    unlinkedCalls: new Map(),
+    moduleCalls: new Map(),
+    namespaces: new Map(),
+    factoryCalls: new Map(),
+    makes: new Map(),
+    chunkFactories: new Map(),
+    pushCallbacks: new Map(),
+    starts: new Map(),
+    registries: new Set(),
+    pushed: 0,
+    loader: false,
+};
+const functionTypes = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
+const isFunction = (node) => functionTypes.has(node.type);
+const sameKey = (a, b) => a !== undefined && b !== undefined && a.scope === b.scope && a.name === b.name;
+/** The module-linking idioms of a program (above). */
+export function moduleLinks(program, definitions) {
+    const tables = tableLinks(program, definitions);
+    const hoisted = hoistedLinks(program, definitions);
+    if (hoisted.idioms.size === 0)
+        return tables;
+    return {
+        ...tables,
+        idioms: new Set([...tables.idioms, ...hoisted.idioms]),
+        modules: tables.modules + hoisted.modules,
+        defines: [...tables.defines, ...hoisted.defines].sort((a, b) => a.site.start - b.site.start),
+        definers: new Set([...tables.definers, ...hoisted.definers]),
+        moduleCalls: hoisted.moduleCalls,
+        namespaces: hoisted.namespaces,
+        factoryCalls: hoisted.factoryCalls,
+        makes: hoisted.makes,
+    };
+}
+/** The factory tables' idioms: a table and its require, the require's definer, and its interop wrappers (above). */
+function tableLinks(program, definitions) {
+    const parents = new Map();
+    const functions = [];
+    walkTree(program, {
+        enter(node, parent) {
+            if (parent !== null)
+                parents.set(node, parent);
+            if (isFunction(node))
+                functions.push(node);
+        },
+    });
+    // The chunk registries (§6 idiom 6): what the program pushes into them, and its loaders' reads of them. A loader's
+    // table can start empty, as a runtime chunk's does (`var e = {}`): its chunks push all its factories.
+    const { pushes, loads } = registriesOf(program);
+    const empty = loads.length > 0;
+    // The require functions, each with its table.
+    const requires = [];
+    for (const fn of functions) {
+        if (fn.type !== 'FunctionDeclaration')
+            continue;
+        const id = fn['id'];
+        const [param] = fn['params'];
+        if (id === null || param?.type !== 'Identifier')
+            continue;
+        const table = tableRead(fn, param['name'], id['name']);
+        if (table === undefined)
+            continue;
+        const key = referenceKey(fn, id['name']);
+        if (key !== undefined)
+            requires.push({ fn, key, table });
+    }
+    const registry = {
+        registries: new Set([...pushes.map((push) => push.registry), ...loads.map((load) => load.registry)]),
+        pushed: pushes.reduce((sum, push) => sum + push.factories.length, 0),
+        loader: loads.length > 0,
+    };
+    if (requires.length === 0) {
+        // A `.cw` wrapper with no table, over a concatenated CommonJS module: `r.cw(function (t, e) { … })`.
+        const idioms = new Set(wraps() ? ['interop'] : []);
+        if (registry.loader)
+            idioms.add('chunk-loader');
+        return { ...none, ...registry, idioms, tables: idioms.has('interop') };
+    }
+    // Each factory's module id, and the key its require parameter has.
+    const factoryIds = new Map();
+    const factories = new Map();
+    const requireKeys = requires.map(({ fn, key, table }) => ({
+        key,
+        fn,
+        table,
+    }));
+    let modules = 0;
+    for (const { fn, table } of requires) {
+        for (const [id, factory] of table.factories) {
+            modules++;
+            factoryIds.set(factory, id);
+            factories.set(factory, { module: id, require: fn, call: table.call });
+            const param = factory['params'][2];
+            if (param?.type !== 'Identifier')
+                continue;
+            const key = referenceKey(factory, param['name']);
+            if (key !== undefined)
+                requireKeys.push({ key, fn, table });
+        }
+    }
+    // The factories chunks push into a registry a loader reads, joined to the table of the require around the loader: the
+    // innermost require whose enclosing code holds the loader's read of the registry.
+    const chunkFactories = new Map();
+    const pushCallbacks = new Map();
+    const chunked = new Map();
+    for (const push of pushes) {
+        const load = loads.find((each) => each.registry === push.registry);
+        if (load === undefined)
+            continue;
+        let found;
+        for (const { fn, table } of requires) {
+            let owner = program;
+            for (let at = parents.get(fn); at !== undefined; at = parents.get(at)) {
+                if (isFunction(at)) {
+                    owner = at;
+                    break;
+                }
+            }
+            if (owner.start > load.read.start || load.read.end > owner.end)
+                continue;
+            if (found === undefined || owner.start > found.owner.start)
+                found = { fn, table, owner };
+        }
+        if (found === undefined)
+            continue;
+        let byId = chunked.get(found.table);
+        if (byId === undefined) {
+            chunked.set(found.table, (byId = new Map()));
+            chunkFactories.set(found.table.literal, byId);
+        }
+        // The callback's first parameter is the require: `t => t(t.s = 4429)`.
+        const callback = push.callback;
+        const first = callback === undefined ? undefined : callback['params'][0];
+        if (callback !== undefined && first?.type === 'Identifier') {
+            pushCallbacks.set(callback, push.call);
+            const key = referenceKey(callback, first['name']);
+            if (key !== undefined)
+                requireKeys.push({ key, fn: found.fn, table: found.table, callback: true });
+        }
+        for (const { id, factory } of push.factories) {
+            const list = byId.get(id);
+            if (list === undefined)
+                byId.set(id, [factory]);
+            else
+                list.push(factory);
+            factoryIds.set(factory, id);
+            factories.set(factory, { module: id, require: found.fn, call: found.table.call });
+            const param = factory['params'][2];
+            if (param?.type !== 'Identifier')
+                continue;
+            const key = referenceKey(factory, param['name']);
+            if (key !== undefined)
+                requireKeys.push({ key, fn: found.fn, table: found.table });
+        }
+    }
+    /** Whether a require's table, or a chunk pushed into it, has a factory of module `id`. */
+    const linksTo = (table, id) => table.factories.has(id) || (chunked.get(table)?.has(id) ?? false);
+    /** The require function a name is, with its table. */
+    const requireOf = (node) => {
+        if (node.type !== 'Identifier')
+            return undefined;
+        const key = definitions.keyOf(node);
+        return requireKeys.find((each) => sameKey(each.key, key));
+    };
+    /** The module a node is in: the id of the factory around it. */
+    const moduleOf = (node) => {
+        for (let at = node; at !== undefined; at = parents.get(at)) {
+            const id = factoryIds.get(at);
+            if (id !== undefined)
+                return id;
+        }
+        return undefined;
+    };
+    const idioms = new Set();
+    const defines = [];
+    const definers = new Set();
+    const links = new Map();
+    const firsts = new Map();
+    const broken = [];
+    const brokenCalls = new Map();
+    const brokenBinds = new Map();
+    const starts = new Map();
+    walkTree(program, {
+        enter(node) {
+            if (node.type === 'AssignmentExpression' && node['operator'] === '=') {
+                // The definer: `R.d = function…`.
+                const left = node['left'];
+                const right = node['right'];
+                if (member(left, 'd') && requireOf(left['object']) !== undefined && isFunction(right))
+                    definers.add(right);
+                return;
+            }
+            if (node.type !== 'CallExpression')
+                return;
+            const callee = calleeExpression(node['callee']);
+            const args = node['arguments'];
+            const require = requireOf(callee);
+            if (require !== undefined) {
+                const { fn, table } = require;
+                // A require call.
+                // webpack 4's entry passes its id through an assignment: `n(n.s = 5)`.
+                let [arg] = args;
+                while (arg?.type === 'AssignmentExpression' && arg['operator'] === '=')
+                    arg = arg['right'];
+                const id = arg === undefined ? undefined : literalKey(arg);
+                if (id === undefined) {
+                    const link = { call: node, why: 'non-constant' };
+                    broken.push(link);
+                    brokenCalls.set(node, link);
+                }
+                else if (!linksTo(table, id)) {
+                    const link = { call: node, why: 'missing' };
+                    broken.push(link);
+                    brokenCalls.set(node, link);
+                }
+                else {
+                    idioms.add('factory-table');
+                    links.set(node, { idiom: 'factory-table', module: id });
+                    if (require.callback === true)
+                        starts.set(node, fn);
+                    let own = firsts.get(fn);
+                    if (own === undefined)
+                        firsts.set(fn, (own = new Map()));
+                    if (!own.has(id))
+                        own.set(id, node);
+                }
+                return;
+            }
+            if (callee.type !== 'MemberExpression' || requireOf(callee['object']) === undefined)
+                return;
+            // A require bound to a module's id, which a loader's promise runs: `n.bind(n, 6954)`.
+            if (member(callee, 'bind') && args.length === 2) {
+                const id = literalKey(args[1]);
+                const { table } = requireOf(callee['object']);
+                if (id === undefined || !linksTo(table, id)) {
+                    const link = { call: node, why: id === undefined ? 'non-constant' : 'missing' };
+                    broken.push(link);
+                    brokenBinds.set(node, link);
+                }
+                return;
+            }
+            if (member(callee, 'n') || member(callee, 'cw')) {
+                idioms.add('interop');
+                return;
+            }
+            if (!member(callee, 'd') || args.some((arg) => arg.type === 'SpreadElement'))
+                return;
+            const [object, list, getter] = args;
+            if (object === undefined || list === undefined)
+                return;
+            const module = moduleOf(node);
+            const add = (key, part) => {
+                if (key === undefined)
+                    return;
+                idioms.add('getter-export');
+                const link = module === undefined ? undefined : { idiom: 'getter-export', module, export: key };
+                defines.push({ site: node, object, key, ...part, ...(link === undefined ? {} : { link }) });
+            };
+            if (list.type === 'ObjectExpression') {
+                for (const property of list['properties']) {
+                    if (property.type !== 'Property' || property['kind'] !== 'init')
+                        continue;
+                    const key = property['key'];
+                    const name = property['computed'] === true ? literalKey(key) : key.type === 'Identifier' ? key['name'] : literalKey(key);
+                    add(name, { getter: property['value'] });
+                }
+            }
+            else if (list.type === 'ArrayExpression') {
+                const elements = list['elements'];
+                for (let at = 0; at + 1 < elements.length;) {
+                    const name = elements[at] === null ? undefined : literalKey(elements[at]);
+                    const second = elements[at + 1];
+                    if (name === undefined || second === null || second === undefined || second.type === 'SpreadElement')
+                        break;
+                    if (second.type === 'Literal' && second['value'] === 0) {
+                        const value = elements[at + 2];
+                        if (value === null || value === undefined || value.type === 'SpreadElement')
+                            break;
+                        add(name, { value });
+                        at += 3;
+                    }
+                    else {
+                        add(name, { getter: second });
+                        at += 2;
+                    }
+                }
+            }
+            else if (getter !== undefined && getter.type !== 'SpreadElement') {
+                add(literalKey(list), { getter });
+            }
+        },
+    });
+    // The calls through what a broken link returns.
+    const unlinkedCalls = new Map();
+    if (brokenCalls.size > 0 || brokenBinds.size > 0) {
+        // What a broken link gives flows through a loader's promise (§6 idiom 6): `n.e(5).then(n.bind(n, 6954))` and
+        // `n.e(5).then(() => n(6954))` are promises of the module, which `.then(m => …)` passes on as `m`, and `await`
+        // unwraps.
+        const promised = new Map();
+        // The identifiers whose definitions are being followed. Declared before the first walk, which follows them too.
+        const following = new Set();
+        walkTree(program, {
+            enter(node) {
+                if (node.type !== 'CallExpression')
+                    return;
+                const callee = calleeExpression(node['callee']);
+                const [handler] = node['arguments'];
+                if (!member(callee, 'then') || handler === undefined)
+                    return;
+                const link = brokenFunction(handler);
+                if (link !== undefined)
+                    promised.set(node, link);
+            },
+        });
+        /** The broken link a promise is of. */
+        function brokenPromise(node) {
+            const found = promised.get(node);
+            if (found !== undefined)
+                return found;
+            if (node.type !== 'Identifier')
+                return undefined;
+            return defined(node, brokenPromise);
+        }
+        /** The broken link a function gives: a bound require, or a function that returns a broken module. */
+        function brokenFunction(node) {
+            const bound = brokenBinds.get(node);
+            if (bound !== undefined)
+                return bound;
+            if (node.type !== 'ArrowFunctionExpression' || node['expression'] !== true)
+                return undefined;
+            return brokenValue(node['body']);
+        }
+        /** The broken link whose module a value is. */
+        function brokenValue(node) {
+            const found = brokenCalls.get(node);
+            if (found !== undefined)
+                return found;
+            if (node.type === 'AwaitExpression')
+                return brokenPromise(node['argument']);
+            if (node.type !== 'Identifier')
+                return undefined;
+            const key = definitions.keyOf(node);
+            if (key === undefined)
+                return undefined;
+            // A parameter of a handler that a broken module's promise passes it to: `.then(m => …)`.
+            const fn = key.scope === 'global' ? undefined : key.scope;
+            if (fn !== undefined && isFunction(fn)) {
+                const [first] = fn['params'];
+                const call = parents.get(fn);
+                if (first?.type === 'Identifier' && first['name'] === key.name && call?.type === 'CallExpression') {
+                    const callee = calleeExpression(call['callee']);
+                    if (call['arguments'][0] === fn && member(callee, 'then')) {
+                        const link = brokenPromise(callee['object']);
+                        if (link !== undefined)
+                            return link;
+                    }
+                }
+            }
+            return defined(node, brokenValue);
+        }
+        /** The broken link of the value an identifier's definitions give, as `of` finds it. */
+        function defined(id, of) {
+            const key = definitions.keyOf(id);
+            // A variable defined through itself gives nothing more.
+            if (key === undefined || following.has(id))
+                return undefined;
+            following.add(id);
+            try {
+                for (const definition of definitions.of(key)) {
+                    const source = definition.source;
+                    if (source !== undefined && definition.pattern.type === 'Identifier') {
+                        const link = of(source);
+                        if (link !== undefined)
+                            return link;
+                    }
+                }
+                return undefined;
+            }
+            finally {
+                following.delete(id);
+            }
+        }
+        walkTree(program, {
+            enter(node) {
+                if (node.type !== 'CallExpression')
+                    return;
+                let callee = calleeExpression(node['callee']);
+                if (callee.type === 'MemberExpression')
+                    callee = callee['object'];
+                const link = brokenValue(callee);
+                if (link !== undefined && link.call !== node)
+                    unlinkedCalls.set(node, link);
+            },
+        });
+    }
+    const tables = idioms.size > 0;
+    if (registry.loader)
+        idioms.add('chunk-loader');
+    return {
+        ...none,
+        ...registry,
+        idioms,
+        tables,
+        modules,
+        defines,
+        definers,
+        links,
+        firsts,
+        factories,
+        broken,
+        unlinkedCalls,
+        chunkFactories,
+        pushCallbacks,
+        starts,
+    };
+    /** Whether the program calls a `.cw` wrapper on a CommonJS factory: `x.cw(function (t, e) { … })`. */
+    function wraps() {
+        let found = false;
+        walkTree(program, {
+            enter(node) {
+                if (found)
+                    return false;
+                if (node.type !== 'CallExpression')
+                    return undefined;
+                const [factory, ...rest] = node['arguments'];
+                if (!member(calleeExpression(node['callee']), 'cw') || rest.length > 0 || factory === undefined)
+                    return undefined;
+                found = isFunction(factory) && factory['params'].length >= 1;
+                return undefined;
+            },
+        });
+        return found;
+    }
+    /**
+     * The table a function reads with its parameter `param` as the key in a call that passes the function `self` on:
+     * `T[param](…, self)` or `T[param].call(…, self)`.
+     */
+    function tableRead(fn, param, self) {
+        let found;
+        walkTree(fn['body'], {
+            enter(node) {
+                if (found !== undefined || isFunction(node))
+                    return false;
+                if (node.type !== 'CallExpression')
+                    return undefined;
+                const args = node['arguments'];
+                if (!args.some((arg) => arg.type === 'Identifier' && arg['name'] === self))
+                    return undefined;
+                let callee = node['callee'];
+                if (member(callee, 'call'))
+                    callee = callee['object'];
+                if (callee.type !== 'MemberExpression' || callee['computed'] !== true)
+                    return undefined;
+                const key = callee['property'];
+                const object = callee['object'];
+                if (key.type !== 'Identifier' || key['name'] !== param || object.type !== 'Identifier')
+                    return undefined;
+                found = tableOf(object);
+                if (found !== undefined)
+                    found = { ...found, call: node };
+                return undefined;
+            },
+        });
+        return found;
+    }
+    /** The factory table a name holds: a declarator's literal, or the literal an IIFE passes the parameter it is. */
+    function tableOf(id) {
+        const key = definitions.keyOf(id);
+        if (key === undefined)
+            return undefined;
+        for (const definition of definitions.of(key)) {
+            if (definition.source !== undefined && definition.pattern.type === 'Identifier') {
+                const table = factoryTable(definition.source, empty);
+                if (table !== undefined)
+                    return table;
+            }
+        }
+        // A parameter of a function called at once with the table: webpack 4's `!function(e){…}([…])`.
+        const fn = key.scope === 'global' ? undefined : key.scope;
+        if (fn === undefined || !isFunction(fn))
+            return undefined;
+        const index = fn['params'].findIndex((param) => param.type === 'Identifier' && param['name'] === key.name);
+        let call = parents.get(fn);
+        while (call?.type === 'ParenthesizedExpression')
+            call = parents.get(call);
+        if (index < 0 || call?.type !== 'CallExpression' || calleeExpression(call['callee']) !== fn)
+            return undefined;
+        const arg = call['arguments'][index];
+        return arg === undefined ? undefined : factoryTable(arg, empty);
+    }
+    /** The key a name has in the scope of `fn`, from a reference to it in `fn`'s own code. */
+    function referenceKey(fn, name) {
+        let key;
+        walkTree(fn['body'], {
+            enter(node, parent) {
+                if (key !== undefined)
+                    return false;
+                if (node.type !== 'Identifier' || node['name'] !== name)
+                    return undefined;
+                // Not a property name.
+                if (parent?.type === 'MemberExpression' && parent['property'] === node && parent['computed'] !== true)
+                    return undefined;
+                if (parent?.type === 'Property' && parent['key'] === node && parent['shorthand'] !== true)
+                    return undefined;
+                const found = definitions.keyOf(node);
+                if (found !== undefined && (found.scope === fn || fn.type === 'FunctionDeclaration'))
+                    key = found;
+                return undefined;
+            },
+        });
+        return key;
+    }
+}
+/**
+ * A factory table (above): an object literal whose values are all functions, or an array literal of functions. It is
+ * empty only when `empty` allows, for a loader's table.
+ */
+function factoryTable(literal, empty = false) {
+    const factories = new Map();
+    if (literal.type === 'ObjectExpression') {
+        for (const property of literal['properties']) {
+            if (property.type !== 'Property' || property['kind'] !== 'init' || property['computed'] === true)
+                return undefined;
+            const key = property['key'];
+            const id = key.type === 'Identifier' ? key['name'] : literalKey(key);
+            const value = property['value'];
+            if (id === undefined || !isFunction(value))
+                return undefined;
+            factories.set(id, value);
+        }
+    }
+    else if (literal.type === 'ArrayExpression') {
+        for (const [index, element] of literal['elements'].entries()) {
+            if (element === null)
+                continue;
+            if (!isFunction(element))
+                return undefined;
+            factories.set(String(index), element);
+        }
+    }
+    else
+        return undefined;
+    return factories.size === 0 && !empty ? undefined : { literal, factories };
+}
+/** Whether a node is `o.name`, spelled with a dot. */
+function member(node, name) {
+    if (node.type !== 'MemberExpression' || node['computed'] === true)
+        return false;
+    const property = node['property'];
+    return property.type === 'Identifier' && property['name'] === name;
+}
+/**
+ * The idioms of code whose modules are hoisted into one scope, each module run by a function of its own (§6):
+ *
+ * - **Lazy module thunk**: a maker `(cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports)`,
+ *   whose thunk calls its factory with a fresh `{ exports }`, as esbuild's `__commonJS` and Rolldown's `__commonJSMin`
+ *   are, or `(fn, res) => () => (fn && (res = fn((fn = 0))), res)`, the variant that only runs init, as esbuild's
+ *   `__esm` is. A `try` around the call, or other code beside it, changes nothing. Each call of the maker with a factory
+ *   is a module, named by the variable its thunk goes to, and each call of that thunk runs it. The module object can
+ *   be a variable the maker declares rather than a parameter, and the thunk can call its factory through a variable
+ *   that holds it, with `.call`: webpack's `R.cw = t => { var e; return () => { if (t) { var r = t; t = 0, e = {
+ *   exports: {} }, r.call(e.exports, e, e.exports) } return e.exports } }`, whose factories take `(module, exports)`. A
+ *   maker can be set on an object a variable holds (`R.cw = …`, `{ cw: … }`), and is then called through it.
+ * - **Memoized getter**: a function with no parameters that first tests a flag declared outside it, returning a value
+ *   when it is set, and sets the flag to `1` or `true` (Rollup commonjs's `requireX`: `if (f) return x; f = 1; …`, `return f ? x : ((f = 1), (x = …))`). It is a
+ *   module, named by its name, and each call of it runs it.
+ * - **Getter export definer**: a function whose own code runs `for (k in all) define(target, k, { get: all[k] })`
+ *   over its parameter `all`, where `target` is its other parameter (esbuild's `__export(target, all)`), or a fresh
+ *   object it returns (Rolldown's `__exportAll(all)`). Each call with an object literal of getters defines its exports,
+ *   of a module named by the target's variable, or by the variable the returned object goes to.
+ * - **Interop wrappers**: a function that reads its first parameter's `__esModule`, and either defines `"default"` with
+ *   that parameter as its value (`__toESM`, which makes a namespace object of a CommonJS module) or reads its `default`
+ *   (`getDefaultExportFromCjs`). A call of one counts, and links when its argument is a call that runs a module.
+ *
+ * A module's name is build-local, like a module id: it appears in the trace, never in identity.
+ */
+function hoistedLinks(program, definitions) {
+    const parents = new Map();
+    const functions = [];
+    const calls = [];
+    walkTree(program, {
+        enter(node, parent) {
+            if (parent !== null)
+                parents.set(node, parent);
+            if (isFunction(node))
+                functions.push(node);
+            else if (node.type === 'CallExpression')
+                calls.push(node);
+        },
+    });
+    /** Whether `node` is a reference to the parameter `name` of `fn`. */
+    const isParam = (node, fn, name) => node?.type === 'Identifier' && node['name'] === name && definitions.keyOf(node)?.scope === fn;
+    const paramNames = (fn) => fn['params'].map((param) => (param.type === 'Identifier' ? param['name'] : undefined));
+    /** The variable a value goes to: a declarator's, or a plain assignment's. */
+    const bindingOf = (value) => {
+        const parent = parents.get(value);
+        if (parent?.type === 'VariableDeclarator' && parent['init'] === value) {
+            const id = parent['id'];
+            return id.type === 'Identifier' ? id : undefined;
+        }
+        if (parent?.type === 'AssignmentExpression' && parent['right'] === value && parent['operator'] === '=') {
+            const left = parent['left'];
+            return left.type === 'Identifier' ? left : undefined;
+        }
+        return undefined;
+    };
+    /** The name a function is called by, with a test of whether a callee's variable is that name. */
+    const nameOf = (fn) => {
+        if (fn.type === 'FunctionDeclaration') {
+            const id = fn['id'];
+            if (id === null)
+                return undefined;
+            const name = id['name'];
+            // A function declaration's calls resolve to the declaration itself, or, at a classic script's top level, to the
+            // global object's property it binds.
+            const topLevel = [...ancestors(fn)].every((each) => !isFunction(each));
+            // Where a parameter shadows the name, a call outside the function is keyed by its `id` (`shadowedNameOf`).
+            return {
+                name,
+                is: (key) => key?.name === name &&
+                    (key.scope === fn || shadowedNameOf(key.scope) === fn || (key.scope === 'global' && topLevel)),
+            };
+        }
+        const id = bindingOf(fn);
+        if (id === undefined)
+            return undefined;
+        const own = definitions.keyOf(id);
+        return own === undefined ? undefined : { name: id['name'], is: (key) => sameKey(key, own) };
+    };
+    function* ancestors(node) {
+        for (let at = parents.get(node); at !== undefined; at = parents.get(at))
+            yield at;
+    }
+    /** The calls whose callee is a variable `is` accepts, past `(0, f)`. */
+    const callsOf = (is) => calls.filter((call) => {
+        const callee = calleeExpression(call['callee']);
+        return callee.type === 'Identifier' && is(definitions.keyOf(callee));
+    });
+    /**
+     * The calls of a function set as a property of an object a variable holds, through that variable: `R.cw(…)` after
+     * `R.cw = fn`, or after `const R = { cw: fn }`.
+     */
+    const memberCallsOf = (fn) => {
+        const parent = parents.get(fn);
+        let holder;
+        let name;
+        if (parent?.type === 'AssignmentExpression' && parent['right'] === fn && parent['operator'] === '=') {
+            const left = parent['left'];
+            const object = left['object'];
+            if (left.type !== 'MemberExpression' || left['computed'] === true || object?.type !== 'Identifier')
+                return undefined;
+            holder = object;
+            name = left['property']['name'];
+        }
+        else if (parent?.type === 'Property' && parent['value'] === fn && parent['kind'] === 'init' && parent['computed'] !== true) {
+            const literal = parents.get(parent);
+            holder = literal === undefined ? undefined : bindingOf(literal);
+            name = propertyName(parent);
+        }
+        const key = holder === undefined ? undefined : definitions.keyOf(holder);
+        if (key === undefined || name === undefined)
+            return undefined;
+        return calls.filter((call) => {
+            const callee = calleeExpression(call['callee']);
+            if (!member(callee, name))
+                return false;
+            const object = callee['object'];
+            return object.type === 'Identifier' && sameKey(definitions.keyOf(object), key);
+        });
+    };
+    const idioms = new Set();
+    const moduleCalls = new Map();
+    const defines = [];
+    const definers = new Set();
+    const namespaces = new Map();
+    const factoryCalls = new Map();
+    const makes = new Map();
+    let modules = 0;
+    for (const fn of functions) {
+        const maker = thunkMaker(fn);
+        const kind = maker === undefined ? (memoizedGetter(fn) ? 'getter' : undefined) : 'thunk';
+        if (kind === undefined)
+            continue;
+        const named = nameOf(fn);
+        // A thunk maker can be set on an object instead (`R.cw = t => …`), and called through it (`R.cw(factory)`).
+        const made = named !== undefined ? callsOf(named.is) : maker !== undefined ? memberCallsOf(fn) : undefined;
+        if (made === undefined)
+            continue;
+        if (maker !== undefined)
+            factoryCalls.set(maker.call, maker.factoryCall);
+        if (kind === 'getter') {
+            if (named === undefined)
+                continue;
+            // A memoized getter is itself the module.
+            modules++;
+            idioms.add('memoized-getter');
+            for (const call of callsOf(named.is)) {
+                if (call['arguments'].length === 0)
+                    moduleCalls.set(call, { idiom: 'memoized-getter', module: named.name });
+            }
+            continue;
+        }
+        // Each call of a thunk maker with a factory is a module, whose thunk runs it.
+        for (const make of made) {
+            const [factory] = make['arguments'];
+            if (factory === undefined || !isFunction(factory))
+                continue;
+            const thunk = bindingOf(make);
+            const key = thunk === undefined ? undefined : definitions.keyOf(thunk);
+            if (key === undefined)
+                continue;
+            makes.set(make, fn);
+            modules++;
+            idioms.add('lazy-thunk');
+            const module = thunk['name'];
+            for (const call of callsOf((each) => sameKey(each, key))) {
+                if (call['arguments'].length === 0)
+                    moduleCalls.set(call, { idiom: 'lazy-thunk', module });
+            }
+        }
+    }
+    for (const fn of functions) {
+        const definer = exportDefiner(fn);
+        if (definer === undefined)
+            continue;
+        const named = nameOf(fn);
+        if (named === undefined)
+            continue;
+        definers.add(fn);
+        for (const call of callsOf(named.is)) {
+            const args = call['arguments'];
+            const list = args[definer.list];
+            const object = definer.target === undefined ? call : args[definer.target];
+            if (list?.type !== 'ObjectExpression' || object === undefined || object.type === 'SpreadElement')
+                continue;
+            const holder = definer.target === undefined ? bindingOf(call) : object.type === 'Identifier' ? object : undefined;
+            const module = holder === undefined ? undefined : holder['name'];
+            for (const property of list['properties']) {
+                if (property.type !== 'Property' || property['kind'] !== 'init')
+                    continue;
+                const key = property['key'];
+                const name = property['computed'] === true ? literalKey(key) : key.type === 'Identifier' ? key['name'] : literalKey(key);
+                if (name === undefined)
+                    continue;
+                idioms.add('getter-export');
+                const link = module === undefined ? undefined : { idiom: 'getter-export', module, export: name };
+                defines.push({ site: call, object, key: name, getter: property['value'], ...(link === undefined ? {} : { link }) });
+            }
+        }
+    }
+    for (const fn of functions) {
+        const wrapper = interopWrapper(fn);
+        if (wrapper === undefined)
+            continue;
+        const named = nameOf(fn);
+        if (named === undefined)
+            continue;
+        if (wrapper === 'namespace')
+            definers.add(fn);
+        for (const call of callsOf(named.is)) {
+            const [arg] = call['arguments'];
+            if (arg === undefined || arg.type === 'SpreadElement')
+                continue;
+            idioms.add('interop');
+            if (wrapper === 'namespace')
+                namespaces.set(call, arg);
+            const inner = moduleCalls.get(arg);
+            if (inner !== undefined)
+                moduleCalls.set(call, { idiom: 'interop', module: inner.module });
+        }
+    }
+    return { ...none, idioms, modules, defines, definers, moduleCalls, namespaces, factoryCalls, makes };
+    /** Whether a variable is declared in a function's code: its parameters', its body's, or a nested scope's there. */
+    function within(key, fn) {
+        return key.scope !== 'global' && fn.start <= key.scope.start && key.scope.end <= fn.end;
+    }
+    /** Whether a function is a lazy module thunk maker (above), and which, with its thunk's call of its factory. */
+    function thunkMaker(fn) {
+        const [cb] = paramNames(fn);
+        if (cb === undefined)
+            return undefined;
+        const inner = returnedFunction(fn);
+        if (inner === undefined)
+            return undefined;
+        const body = inner['body'];
+        // The module object: a variable of the maker's own, a parameter or one it declares, that the thunk sets to a fresh
+        // `{ exports }`.
+        let mod;
+        let object;
+        walkTree(body, {
+            enter(node) {
+                if (mod !== undefined || isFunction(node))
+                    return false;
+                if (node.type !== 'AssignmentExpression' || node['operator'] !== '=')
+                    return undefined;
+                const left = node['left'];
+                const right = node['right'];
+                const key = left.type === 'Identifier' ? definitions.keyOf(left) : undefined;
+                if (key === undefined || !within(key, fn) || within(key, inner) || key.name === cb || right.type !== 'ObjectExpression')
+                    return undefined;
+                if (right['properties'].some((each) => propertyName(each) === 'exports')) {
+                    mod = key;
+                    object = right;
+                }
+                return undefined;
+            },
+        });
+        // The factory: `cb`, or a variable of the thunk's that only ever holds it (`var r = t; t = 0`).
+        const isFactory = (node) => {
+            if (isParam(node, fn, cb))
+                return true;
+            const key = node.type === 'Identifier' ? definitions.keyOf(node) : undefined;
+            if (key === undefined || !within(key, inner))
+                return false;
+            const defined = definitions.of(key);
+            return defined.length > 0 && defined.every((each) => each.source !== undefined && isParam(each.source, fn, cb));
+        };
+        let found;
+        walkTree(body, {
+            enter(node) {
+                if (found !== undefined || isFunction(node))
+                    return false;
+                if (node.type !== 'CallExpression')
+                    return undefined;
+                const callee = node['callee'];
+                // `cb(…)`, or `cb.call(this, …)`.
+                const through = member(callee, 'call');
+                if (!isFactory(through ? callee['object'] : callee))
+                    return undefined;
+                const args = node['arguments'].slice(through ? 1 : 0);
+                const [first] = args;
+                // `cb(cb = 0)`: init only.
+                if (first?.type === 'AssignmentExpression' && isParam(first['left'], fn, cb)) {
+                    const right = first['right'];
+                    if (right.type === 'Literal' && right['value'] === 0)
+                        found = { kind: 'init', call: node, factoryCall: {} };
+                    return undefined;
+                }
+                // `cb((mod = { exports: {} }).exports, mod)`, `r.call(mod.exports, mod, mod.exports)`.
+                if (mod === undefined)
+                    return undefined;
+                const module = args.findIndex((arg) => arg.type === 'Identifier' && sameKey(definitions.keyOf(arg), mod));
+                found = { kind: 'commonjs', call: node, factoryCall: { object: object, ...(module < 0 ? {} : { module }) } };
+                return undefined;
+            },
+        });
+        return found;
+    }
+    /** Whether a function is a memoized getter (above). */
+    function memoizedGetter(fn) {
+        if (fn['params'].length > 0 || fn['async'] === true || fn['generator'] === true)
+            return false;
+        const body = fn['body'];
+        if (body.type !== 'BlockStatement')
+            return false;
+        const [first] = body['body'];
+        // The flag the getter tests first: `if (f) return x`, `return f ? … : …`, `return f || (…), x`. The early return
+        // gives the memoized value: a run-once guard (`if (done) return; done = true; …`) is not a module.
+        let test;
+        if (first?.type === 'IfStatement' && returnsValue(first['consequent']))
+            test = first['test'];
+        else if (first?.type === 'ReturnStatement' && first['argument'] !== null) {
+            let argument = first['argument'];
+            if (argument.type === 'SequenceExpression')
+                argument = argument['expressions'][0];
+            if (argument.type === 'ConditionalExpression')
+                test = argument['test'];
+            else if (argument.type === 'LogicalExpression')
+                test = argument['left'];
+        }
+        if (test?.type !== 'Identifier')
+            return false;
+        const flag = definitions.keyOf(test);
+        if (flag === undefined || flag.scope === fn)
+            return false;
+        let sets = false;
+        walkTree(body, {
+            enter(node) {
+                if (sets || isFunction(node))
+                    return false;
+                if (node.type !== 'AssignmentExpression' || node['operator'] !== '=')
+                    return undefined;
+                const left = node['left'];
+                const right = node['right'];
+                const truthy = (right.type === 'Literal' && (right['value'] === 1 || right['value'] === true)) ||
+                    (right.type === 'UnaryExpression' && right['operator'] === '!' && right['argument'].type === 'Literal' && right['argument']['value'] === 0);
+                if (left.type === 'Identifier' && truthy && sameKey(definitions.keyOf(left), flag))
+                    sets = true;
+                return undefined;
+            },
+        });
+        return sets;
+    }
+    /** Whether a statement is `return x`, alone or as a block's only statement. */
+    function returnsValue(statement) {
+        const [only, ...rest] = statement.type === 'BlockStatement' ? statement['body'] : [statement];
+        return rest.length === 0 && only?.type === 'ReturnStatement' && only['argument'] !== null;
+    }
+    /**
+     * Whether a function is a getter export definer (above): the index of its parameter whose getters it defines, and of
+     * the one it defines them on, or none when it defines them on a fresh object it returns.
+     */
+    function exportDefiner(fn) {
+        const names = paramNames(fn);
+        let found;
+        walkTree(fn['body'], {
+            enter(node) {
+                if (found !== undefined || isFunction(node))
+                    return false;
+                if (node.type !== 'ForInStatement')
+                    return undefined;
+                const right = node['right'];
+                const list = names.findIndex((name) => name !== undefined && isParam(right, fn, name));
+                const left = node['left'];
+                const variable = left.type === 'VariableDeclaration' ? left['declarations'][0]['id'] : left;
+                if (list < 0 || variable.type !== 'Identifier')
+                    return undefined;
+                // `define(target, k, { get: all[k], … })`
+                walkTree(node['body'], {
+                    enter(part) {
+                        if (found !== undefined || isFunction(part))
+                            return false;
+                        if (part.type !== 'CallExpression')
+                            return undefined;
+                        const [target, key, descriptor] = part['arguments'];
+                        if (target?.type !== 'Identifier' || key?.type !== 'Identifier' || key['name'] !== variable['name'])
+                            return undefined;
+                        if (descriptor?.type !== 'ObjectExpression')
+                            return undefined;
+                        const getter = descriptor['properties'].find((each) => propertyName(each) === 'get')?.['value'];
+                        if (getter?.type !== 'MemberExpression' || getter['computed'] !== true || !isParam(getter['object'], fn, names[list]))
+                            return undefined;
+                        const index = names.findIndex((name) => name !== undefined && isParam(target, fn, name));
+                        if (index >= 0)
+                            found = { list, target: index };
+                        else if (definitions.keyOf(target)?.scope !== 'global' && returns(fn, target['name']))
+                            found = { list };
+                        return undefined;
+                    },
+                });
+                return undefined;
+            },
+        });
+        return found;
+    }
+    /** Whether a function is an interop wrapper (above), and which. */
+    function interopWrapper(fn) {
+        const [param] = paramNames(fn);
+        if (param === undefined)
+            return undefined;
+        let esModule = false;
+        let namespace = false;
+        let reads = false;
+        walkTree(fn['body'], {
+            enter(node) {
+                if (isFunction(node))
+                    return false;
+                if (node.type === 'MemberExpression' && isParam(node['object'], fn, param)) {
+                    const property = node['property'];
+                    const name = node['computed'] === true ? stringKey(property) : property['name'];
+                    if (name === '__esModule')
+                        esModule = true;
+                    if (name === 'default')
+                        reads = true;
+                }
+                else if (node.type === 'CallExpression') {
+                    // `define(ns, "default", { value: m, … })`
+                    const [, key, descriptor] = node['arguments'];
+                    if (key !== undefined && stringKey(key) === 'default' && descriptor?.type === 'ObjectExpression') {
+                        const value = descriptor['properties'].find((each) => propertyName(each) === 'value')?.['value'];
+                        if (isParam(value, fn, param))
+                            namespace = true;
+                    }
+                }
+                return undefined;
+            },
+        });
+        return !esModule ? undefined : namespace ? 'namespace' : reads ? 'default' : undefined;
+    }
+    /** The function a function returns: its arrow's body, or its only `return`'s. */
+    function returnedFunction(fn) {
+        const body = fn['body'];
+        if (isFunction(body))
+            return body;
+        if (body.type !== 'BlockStatement')
+            return undefined;
+        const statements = body['body'];
+        const last = statements.at(-1);
+        const argument = last?.type === 'ReturnStatement' ? last['argument'] : null;
+        return argument !== null && isFunction(argument) ? argument : undefined;
+    }
+    /** Whether a function's own code returns the variable `name`, alone or last in a sequence. */
+    function returns(fn, name) {
+        let found = false;
+        walkTree(fn['body'], {
+            enter(node) {
+                if (found || isFunction(node))
+                    return false;
+                if (node.type !== 'ReturnStatement' || node['argument'] === null)
+                    return undefined;
+                const argument = calleeExpression(node['argument']);
+                found = argument.type === 'Identifier' && argument['name'] === name;
+                return undefined;
+            },
+        });
+        return found;
+    }
+}
+/** The name a property's key gives it: an identifier or a literal, spelled plainly or computed. */
+function propertyName(property) {
+    const key = property['key'];
+    if (key === undefined)
+        return undefined;
+    if (property['computed'] === true)
+        return stringKey(key);
+    return key.type === 'Identifier' ? key['name'] : literalKey(key);
+}
+/** A literal's key, or a template literal's with no substitutions (Rolldown quotes its strings so). */
+function stringKey(node) {
+    if (node.type !== 'TemplateLiteral' || node['expressions'].length > 0)
+        return literalKey(node);
+    const [quasi] = node['quasis'];
+    return quasi?.['value']?.cooked ?? undefined;
+}