monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/analysis/lib/chunk-registry.d.ts

@@ -0,0 +1,45 @@
+import { type AstNode } from './ast.ts';
+/** A push into a registry: its call, the chunk ids it pushes, and its factories by module id. */
+export interface RegistryPush {
+    registry: string;
+    call: AstNode;
+    chunks: string[];
+    /** The factories it pushes, each with its module id, in document order. */
+    factories: {
+        id: string;
+        factory: AstNode;
+    }[];
+    /** The callback it pushes, which the loader calls with its require. */
+    callback?: AstNode;
+}
+/** A loader's read of a registry: the registry's name, the read, and the ids its id table maps ('any' for every id). */
+export interface RegistryLoad {
+    registry: string;
+    read: AstNode;
+    ids: ReadonlySet<string> | 'any';
+}
+export interface Registries {
+    pushes: RegistryPush[];
+    loads: RegistryLoad[];
+}
+/**
+ * The registry an ESM chunk's export of its module table counts as a push into (above). A global's name can't be it: a
+ * registry read never names it.
+ */
+export declare const esmRegistry = "\0webpack-esm";
+/** The chunk registries a program pushes into and reads (above). */
+export declare function registriesOf(program: AstNode): Registries;
+/**
+ * The chunk registries an artifact's code pushes into and reads, as data: each push's registry and chunk ids, and each
+ * loader's registry and the ids its id table maps (`null` for every id). None when the code doesn't parse.
+ */
+export declare function chunkRegistries(text: string, sourceType: 'script' | 'module'): {
+    pushes: {
+        registry: string;
+        chunks: string[];
+    }[];
+    loads: {
+        registry: string;
+        ids: string[] | null;
+    }[];
+};

package/dist/packages/analysis/lib/chunk-registry.js

@@ -0,0 +1,334 @@
+// Chunk registries (§6 Module-linking idiom 6, Globals are not links): the global array a chunk loader's chunks push
+// into, recognized from structure alone.
+//
+// - A **registry** is a global object's member with a constant name, read as `G.R = G.R || []` or `G.R ||= []` (and
+//   `G["R"]`), where `G` is `self`, `window`, `globalThis` or `this`.
+// - A **push** is `registry.push([[ids…], modules, callback?])`, where `ids` are constant chunk ids and `modules` an
+//   object literal of factories keyed by constant module id, or an array literal of factories indexed by it.
+// - A **loader** reads a registry into a variable whose `push` it overrides (`l.push = …`), so that it reads every push.
+//   Its **id table** is the ids its URL function maps: a function of one parameter that builds a script URL by string
+//   concatenation (a string literal naming a `.js`, `.mjs` or `.cjs` file), such as `n.u = e => ({581: "recorder"}[e] +
+//   "." + {581: "27e3"}[e] + ".js")`. Each object literal it indexes with the parameter maps only its constant keys, so
+//   the function maps the ids every such literal has. A literal with a fallback (`{…}[e] || e`) and the parameter itself
+//   (`e => e + ".js"`) map every id. When no function builds a script URL, every concatenating function counts, and one
+//   with a table outweighs one that maps every id: an unrelated `e => "\\" + e` never widens a loader's table.
+//
+// - An **ESM chunk** (webpack's ESM chunk format) doesn't push: the module exports its chunk ids and its module
+//   table, `export const __webpack_esm_ids__ = [ids…]` and `export const __webpack_esm_modules__ = {factories}`. It
+//   counts as a push into the registry `esmRegistry`, which no global names. Its **loader** loads it with `import()`
+//   and destructures the module's `__webpack_esm_modules__` (`let {__webpack_esm_modules__: o} = e`) to install them,
+//   which counts as a read of that registry, with the id table of its URL function.
+//
+// Registry names and chunk ids are build-local: they decide links, never identity (§6 Reporting).
+import { walkTree } from "./ast.js";
+import { literalKey } from "./keys.js";
+import { parse } from "./parse.js";
+/**
+ * The registry an ESM chunk's export of its module table counts as a push into (above). A global's name can't be it: a
+ * registry read never names it.
+ */
+export const esmRegistry = '\u0000webpack-esm';
+/** The names an ESM chunk exports its chunk ids and its module table under. */
+const esmIds = '__webpack_esm_ids__';
+const esmModules = '__webpack_esm_modules__';
+/** The chunk registries a program pushes into and reads (above). */
+export function registriesOf(program) {
+    const pushes = [];
+    // The ESM chunk exports of each statement list, by the node that holds it.
+    const exported = new Map();
+    const esmReads = [];
+    // The variables registry reads are stored in, by name, with the registry and the read: `l = self.R = self.R || []`.
+    const stored = [];
+    const hooked = new Set();
+    const tables = [];
+    walkTree(program, {
+        enter(node, parent) {
+            if (node.type === 'CallExpression') {
+                const push = pushOf(node);
+                if (push !== undefined)
+                    pushes.push(push);
+                return;
+            }
+            if (node.type === 'VariableDeclarator') {
+                const id = node['id'];
+                const init = node['init'];
+                const registry = init === null ? undefined : registryRead(init);
+                if (registry !== undefined && id.type === 'Identifier')
+                    stored.push({ name: id['name'], registry, read: init });
+                return;
+            }
+            if (node.type === 'AssignmentExpression' && node['operator'] === '=') {
+                const left = node['left'];
+                const right = node['right'];
+                const registry = registryRead(right);
+                if (registry !== undefined && left.type === 'Identifier')
+                    stored.push({ name: left['name'], registry, read: right });
+                // `l.push = …`: the loader reads every push.
+                const object = left.type === 'MemberExpression' ? left['object'] : undefined;
+                if (object?.type === 'Identifier' && memberName(left) === 'push')
+                    hooked.add(object['name']);
+                return;
+            }
+            if (node.type === 'ExportNamedDeclaration' && parent !== null) {
+                const declaration = node['declaration'];
+                if (declaration?.type !== 'VariableDeclaration')
+                    return;
+                for (const declarator of declaration['declarations']) {
+                    const id = declarator['id'];
+                    const init = declarator['init'];
+                    if (id.type !== 'Identifier' || init === null)
+                        continue;
+                    const entry = exported.get(parent) ?? {};
+                    if (id['name'] === esmIds && init.type === 'ArrayExpression') {
+                        const ids = init['elements'].map((element) => (element === null ? undefined : literalKey(element)));
+                        if (ids.every((each) => each !== undefined))
+                            entry.ids = ids;
+                    }
+                    else if (id['name'] === esmModules && init.type === 'ObjectExpression') {
+                        entry.modules = init;
+                        entry.declaration = node;
+                    }
+                    exported.set(parent, entry);
+                }
+                return;
+            }
+            if (node.type === 'ObjectPattern') {
+                const reads = node['properties'].some((property) => property.type === 'Property' && property['computed'] !== true && keyName(property['key']) === esmModules);
+                if (reads)
+                    esmReads.push(node);
+                return;
+            }
+            if (isFunction(node)) {
+                const table = idTable(node);
+                if (table !== undefined)
+                    tables.push(table);
+            }
+        },
+    });
+    for (const { ids, modules, declaration } of exported.values()) {
+        if (ids === undefined || modules === undefined || declaration === undefined)
+            continue;
+        const factories = objectFactories(modules);
+        if (factories !== undefined)
+            pushes.push({ registry: esmRegistry, call: declaration, chunks: ids, factories });
+    }
+    const ids = mappedIds(tables);
+    const loads = [];
+    for (const { name, registry, read } of stored) {
+        if (!hooked.has(name) || loads.some((load) => load.read === read))
+            continue;
+        loads.push({ registry, read, ids });
+    }
+    for (const read of esmReads)
+        loads.push({ registry: esmRegistry, read, ids });
+    return { pushes, loads };
+}
+/**
+ * The chunk registries an artifact's code pushes into and reads, as data: each push's registry and chunk ids, and each
+ * loader's registry and the ids its id table maps (`null` for every id). None when the code doesn't parse.
+ */
+export function chunkRegistries(text, sourceType) {
+    // A cheap test first: code that never names `push` neither pushes nor hooks one, unless it is an ESM chunk or loader.
+    if (!text.includes('push') && !text.includes(esmModules))
+        return { pushes: [], loads: [] };
+    const parsed = parse(text, sourceType);
+    if ('error' in parsed)
+        return { pushes: [], loads: [] };
+    const { pushes, loads } = registriesOf(parsed.program);
+    return {
+        pushes: pushes.map(({ registry, chunks }) => ({ registry, chunks })),
+        loads: loads.map(({ registry, ids }) => ({ registry, ids: ids === 'any' ? null : [...ids].sort() })),
+    };
+}
+const globalNames = new Set(['self', 'window', 'globalThis']);
+/** The registry an expression reads, `G.R = G.R || []` or `G.R ||= []`, by its name. */
+function registryRead(node) {
+    if (node.type !== 'AssignmentExpression')
+        return undefined;
+    const left = node['left'];
+    const right = node['right'];
+    const name = globalMember(left);
+    if (name === undefined || name === esmRegistry)
+        return undefined;
+    if (node['operator'] === '||=' || node['operator'] === '??=')
+        return emptyArray(right) ? name : undefined;
+    if (node['operator'] !== '=' || right.type !== 'LogicalExpression' || right['operator'] !== '||')
+        return undefined;
+    return globalMember(right['left']) === name && emptyArray(right['right']) ? name : undefined;
+}
+/** `G.R` or `G["R"]` with `G` a name of the global object, or `this`: the member's name. */
+function globalMember(node) {
+    if (node.type !== 'MemberExpression')
+        return undefined;
+    const object = node['object'];
+    const global = object.type === 'ThisExpression' || (object.type === 'Identifier' && globalNames.has(object['name']));
+    return global ? memberName(node) : undefined;
+}
+/** A member expression's constant name: `o.x` or `o["x"]`. */
+function memberName(node) {
+    if (node.type !== 'MemberExpression')
+        return undefined;
+    const property = node['property'];
+    if (node['computed'] !== true)
+        return property.type === 'Identifier' ? property['name'] : undefined;
+    return property.type === 'Literal' && typeof property['value'] === 'string' ? property['value'] : undefined;
+}
+const emptyArray = (node) => node.type === 'ArrayExpression' && node['elements'].length === 0;
+/** A push into a registry (above), or undefined for any other call. */
+function pushOf(call) {
+    const callee = call['callee'];
+    if (callee.type !== 'MemberExpression' || memberName(callee) !== 'push')
+        return undefined;
+    const object = callee['object'];
+    const registry = registryRead(object) ?? globalMember(object);
+    if (registry === undefined)
+        return undefined;
+    const [only, ...rest] = call['arguments'];
+    if (only?.type !== 'ArrayExpression' || rest.length > 0)
+        return undefined;
+    const [list, modules, callback] = only['elements'];
+    if (list?.type !== 'ArrayExpression' || modules === null || modules === undefined)
+        return undefined;
+    const chunks = [];
+    for (const element of list['elements']) {
+        const id = element === null ? undefined : literalKey(element);
+        if (id === undefined)
+            return undefined;
+        chunks.push(id);
+    }
+    let factories = [];
+    if (modules.type === 'ObjectExpression') {
+        const found = objectFactories(modules);
+        if (found === undefined)
+            return undefined;
+        factories = found;
+    }
+    else if (modules.type === 'ArrayExpression') {
+        for (const [index, element] of modules['elements'].entries()) {
+            if (element === null)
+                continue;
+            if (!isFunction(element))
+                return undefined;
+            factories.push({ id: String(index), factory: element });
+        }
+    }
+    else
+        return undefined;
+    const push = { registry, call, chunks, factories };
+    if (callback !== null && callback !== undefined && isFunction(callback))
+        push.callback = callback;
+    return push;
+}
+/** An object literal of factories keyed by constant module id, or undefined when it is anything else. */
+function objectFactories(modules) {
+    const factories = [];
+    for (const property of modules['properties']) {
+        if (property.type !== 'Property' || property['kind'] !== 'init' || property['computed'] === true)
+            return undefined;
+        const id = keyName(property['key']);
+        const value = property['value'];
+        if (id === undefined || !isFunction(value))
+            return undefined;
+        factories.push({ id, factory: value });
+    }
+    return factories;
+}
+/** A non-computed property key's name. */
+const keyName = (key) => (key.type === 'Identifier' ? key['name'] : literalKey(key));
+const functionTypes = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
+const isFunction = (node) => functionTypes.has(node.type);
+/**
+ * The ids a program's URL functions map (above): those of the functions that build a script URL when there are any,
+ * else of every concatenating function, a table outweighing 'any'.
+ */
+function mappedIds(tables) {
+    const scripts = tables.filter((table) => table.script);
+    const counted = scripts.length > 0 ? scripts : tables.filter((table) => table.ids !== 'any');
+    if (counted.some((table) => table.ids === 'any'))
+        return 'any';
+    if (counted.length === 0)
+        return tables.length > 0 ? 'any' : new Set();
+    return new Set(counted.flatMap((table) => [...table.ids]));
+}
+const scriptUrl = /\.[cm]?js(?:$|[?#])/i;
+/**
+ * A function's id table (above): the ids it maps, 'any' when it maps every id, and whether it builds a script URL, or
+ * undefined when it concatenates no use of its one parameter.
+ */
+function idTable(fn) {
+    const params = fn['params'];
+    if (params.length !== 1 || params[0].type !== 'Identifier')
+        return undefined;
+    const param = params[0]['name'];
+    const isParam = (node) => node.type === 'Identifier' && node['name'] === param;
+    // The key sets of the tables it indexes with no fallback: an id must be in each.
+    const constraints = [];
+    let used = false;
+    let script = false;
+    walkTree(fn['body'], {
+        enter(node) {
+            if (node !== fn['body'] && isFunction(node))
+                return false;
+            if (node.type !== 'BinaryExpression' || node['operator'] !== '+')
+                return undefined;
+            if (!concatenation(node))
+                return undefined;
+            for (const side of [node['left'], node['right']]) {
+                if (side.type === 'Literal' && typeof side['value'] === 'string' && scriptUrl.test(side['value']))
+                    script = true;
+                if (isParam(side))
+                    used = true;
+                // `{…}[e] || e` keeps a table's id, or the id itself: every id.
+                if (side.type === 'LogicalExpression') {
+                    const operands = [side['left'], side['right']];
+                    if (operands.some((operand) => isParam(operand) || tableKeys(operand, isParam) !== undefined))
+                        used = true;
+                    continue;
+                }
+                const keys = tableKeys(side, isParam);
+                if (keys !== undefined) {
+                    used = true;
+                    constraints.push(keys);
+                }
+            }
+            return undefined;
+        },
+    });
+    if (!used)
+        return undefined;
+    if (constraints.length === 0)
+        return { ids: 'any', script };
+    const [first, ...rest] = constraints;
+    return { ids: new Set(first.filter((id) => rest.every((keys) => keys.includes(id)))), script };
+}
+/** Whether a `+` builds a string: one of its operands, down its left spine, is a string literal. */
+function concatenation(node) {
+    for (let at = node; at.type === 'BinaryExpression' && at['operator'] === '+'; at = at['left']) {
+        const right = at['right'];
+        const left = at['left'];
+        if (right.type === 'Literal' && typeof right['value'] === 'string')
+            return true;
+        if (left.type === 'Literal' && typeof left['value'] === 'string')
+            return true;
+    }
+    return false;
+}
+/** `{k: v, …}[p]`: the literal's constant keys. */
+function tableKeys(node, isParam) {
+    if (node.type !== 'MemberExpression' || node['computed'] !== true || !isParam(node['property']))
+        return undefined;
+    const object = node['object'];
+    if (object.type !== 'ObjectExpression')
+        return undefined;
+    const keys = [];
+    for (const property of object['properties']) {
+        if (property.type !== 'Property' || property['computed'] === true)
+            return undefined;
+        const key = property['key'];
+        const id = key.type === 'Identifier' ? key['name'] : literalKey(key);
+        if (id === undefined)
+            return undefined;
+        keys.push(id);
+    }
+    return keys;
+}

package/dist/packages/analysis/lib/code-routes.d.ts

@@ -0,0 +1,52 @@
+import type { Realm, SerializedCatalog } from '../../../catalog.ts';
+import { type AstNode } from './ast.ts';
+import { type GlobalResolution, type Position } from './global-object.ts';
+import type { ScopeRules } from './scope.ts';
+/** The natives that compile code from strings (§2). */
+export type Compiler = 'eval' | 'setTimeout' | 'setInterval' | 'Function' | '%AsyncFunction%' | '%GeneratorFunction%' | '%AsyncGeneratorFunction%';
+/** The functions the global object holds that compile code from strings, which are no holders. */
+export declare const isGlobalCompiler: (name: unknown) => name is "eval" | "setTimeout" | "setInterval";
+/**
+ * The arguments a call passes: those the analyzer can list, in order (`null` for a hole, which is `undefined`), then
+ * the expression whose value gives any further ones, which it can't list (a spread, or an array that is no literal).
+ */
+export interface Args {
+    items: (AstNode | null)[];
+    rest?: AstNode;
+}
+/** A call that reaches a native that compiles code from strings, the arguments it passes it, and the route it took. */
+export interface IndirectCall {
+    compiler: Compiler;
+    args: Args;
+    /**
+     * Each step of the route that made the call indirect, once: those that reached the native (`a computed key`,
+     * `.constructor`, `.bind`), then those that called it (`.call`, `Reflect.apply`).
+     */
+    via: string[];
+}
+export interface CodeRoutes {
+    /**
+     * The natives that compile code a call, `new` expression or tagged template reaches, one for each native, and how.
+     * The direct forms are not told apart here: the resolver tries them first.
+     */
+    reached(node: AstNode, at: Position): IndirectCall[];
+    /**
+     * The expressions a callee may be (Principle 3): each branch of a conditional or logical expression that its test
+     * doesn't rule out, in source order, or the callee itself.
+     */
+    alternatives(expression: AstNode, at: Position): AstNode[];
+}
+export declare function codeRoutes(context: {
+    catalog: SerializedCatalog;
+    realm: Realm;
+    /** The realm's global holder, e.g. `Window`. */
+    global: string;
+    program: AstNode;
+    scope: ScopeRules;
+    resolution: GlobalResolution;
+}): CodeRoutes;
+/**
+ * The type of the node that stands for a tagged template's strings array: an array, which a string conversion joins
+ * into the template's text, located at the template.
+ */
+export declare const templateStrings = "TemplateStrings";