monkeypatchlist 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,160 @@
+import { type AstNode } from './ast.ts';
+import type { BindingResolver } from './binding.ts';
+import { type Definitions } from './definitions.ts';
+import type { GeneratedLocation } from './types.ts';
+/** How a load site loads a chunk's URL. */
+export type ChunkLoad = 'element' | 'import-scripts' | 'import';
+/**
+ * A chunk load site: how it loads, where its URL expression is, the URLs it folds to, one per constant alternative, and,
+ * when some alternative doesn't fold, the constant prefix every such alternative starts with ('' for none).
+ */
+export interface ChunkLoadSite {
+    load: ChunkLoad;
+    location: GeneratedLocation;
+    urls: string[];
+    prefix?: string;
+    /**
+     * The integrity value the code sets on the chunk's script element for each URL, when it folds to one constant for
+     * that URL (§17 Integrity): `o.integrity = u[a]`, with `u` a constant table by chunk id. A URL without one has
+     * none.
+     */
+    integrity?: Record<string, string>;
+}
+/** The chunk load sites of an artifact's code (above). None when it doesn't parse, or has no URL function. */
+export declare function chunkLoadSites(text: string, sourceType: 'script' | 'module', bindings: BindingResolver): ChunkLoadSite[];
+/** A cheap test first: a URL function concatenates a script URL, and a load site names one of these. */
+export declare const mayLoadChunks: (text: string) => boolean;
+/** A program's URL functions and the load sites that may call one (`chunkCandidates`). */
+export interface ChunkCandidates {
+    functions: Map<AstNode, ReadonlySet<string> | 'any'>;
+    sites: {
+        load: ChunkLoad;
+        url: AstNode;
+        object?: AstNode;
+    }[];
+}
+/** A program's URL functions, and the load sites whose URL expressions may call one. */
+export declare function chunkCandidates(program: AstNode): ChunkCandidates;
+/** The chunk load sites among a program's candidates, folded with `folder`, located through `starts`. */
+export declare function foldChunkSites({ functions, sites }: ChunkCandidates, folder: Folder, starts: readonly number[]): ChunkLoadSite[];
+/** Whether a call creates a script element: `X.createElement("script")`, the tag name in any ASCII case. */
+export declare function isScriptCreation(call: AstNode): boolean;
+/** A member expression's constant name: `o.x` or `o["x"]`. */
+export declare function propertyName(node: AstNode): string | undefined;
+/**
+ * Folds URL expressions in one artifact's program (above), and the URLs code builds for the browser to load (§2 Computed
+ * URLs): besides string concatenation, templates, `new URL(x, base)` for a folded `x` and a base the scan knows,
+ * with its `.href` and `toString()`, and `import.meta.url`, the artifact's own URL. A base of `location` or
+ * `document.baseURI` is the environment's base URL, which the browser resolves a relative URL against anyway, so `x`
+ * folds to itself there. A parameter folds to the arguments every call the program shows passes it, when the
+ * function is called by a name or member it is bound to, or where it is written.
+ */
+export declare class Folder {
+    /** The plain assignments to each member name, by the object's variable. */
+    private members?;
+    /** While a URL is folded, the variables a URL function is given, which hold the chunk id. */
+    private idKeys;
+    /** While an integrity value is folded, the variables that hold the chunk id. */
+    private ids;
+    /** Each node's parent. */
+    private parents?;
+    /** The calls of the program, by the name or member name their callee names. */
+    private calls?;
+    /** The function declarations of the program, by name. */
+    private declarations?;
+    private readonly program;
+    private readonly definitions;
+    private readonly functions;
+    private readonly url;
+    constructor(program: AstNode, definitions: Definitions, functions: ReadonlyMap<AstNode, ReadonlySet<string> | 'any'>, url?: string);
+    /**
+     * What a URL expression folds to outside any chunk loader: its constant string alternatives, and whether some
+     * alternative is unknown. A chunk id never takes a value here.
+     */
+    strings(node: AstNode): {
+        values: string[];
+        unknown: boolean;
+        chunk: boolean;
+    };
+    /** The variable an identifier names, when it is a free name of the global object that no code assigns. */
+    private freeGlobal;
+    /**
+     * Whether an expression is the environment's base URL as a base of `new URL` (§2 Computed URLs): `location`,
+     * its `href`, or `document.baseURI`, through the global object's names.
+     */
+    private isEnvironmentBase;
+    /**
+     * Whether a base is the environment's base URL (`isEnvironmentBase`), also through the one value a name or member is
+     * given, or as the left side of `||`, which is never empty there (webpack's `n.b = document.baseURI || …`).
+     */
+    private isBase;
+    /** Whether an expression is a URL object: `new URL(…)`, or a name whose one definition is one. */
+    private isUrlObject;
+    /** `new URL(x, base)` (URL Standard § URL constructor): each alternative of `x` against each of `base`. */
+    private newUrl;
+    /**
+     * The arguments the calls of a parameter's function pass it, or undefined when the parameter is none, or no call is
+     * shown, or one spreads before it or passes none (`callsOf`).
+     */
+    private parameterArguments;
+    /**
+     * The chunk URLs a load site's URL expression folds to, and the folded prefix of its unknown alternatives, or
+     * undefined when it calls no URL function, so that it is no chunk load.
+     */
+    chunkUrls(url: AstNode, element?: AstNode): {
+        urls: string[];
+        prefix?: string;
+        integrity?: Record<string, string>;
+    } | undefined;
+    /** What each plain `element.integrity = v` assignment to the same variable as `element` assigns. */
+    private integrityWrites;
+    /** Whether `object` is a script element the code creates: `document.createElement("script")`. */
+    isScriptElement(object: AstNode): boolean;
+    /**
+     * The script elements the code creates (`X.createElement("script")`, each by its call) that an expression may be:
+     * the call itself, or a name whose reaching definitions are, through other names, parentheses, comma sequences and
+     * assignments.
+     */
+    elementsOf(node: AstNode, depth?: number): Set<AstNode>;
+    /** The constant prefix of a URL expression: its leading `+` operands that fold to one string, joined. */
+    private prefix;
+    /** A member `o.p` that one plain assignment gives a value, followed to it. */
+    private resolveMember;
+    /** A name whose one reaching definition is an expression, followed to it: `s` in `var s = n.p + n.u(t)`. */
+    private resolveName;
+    /**
+     * What `node` folds to with the URL functions it calls given the chunk id `id` (none: unknown), adding every URL
+     * function it calls to `called`.
+     */
+    private fold;
+    /**
+     * `t[k]`, where `t` is a variable whose only definition is an object literal of constant keys and `k` folds to one
+     * key: the value the literal has there, or `undefined` (no value) when it has none.
+     */
+    private tableRead;
+    /** `{k: v, …}[param]` in a URL function, for the chunk id the parameter holds. */
+    private lookup;
+    /**
+     * The start value of the variable `key` when it is a plain parameter of its function: the union of the arguments the
+     * function's calls pass it (`n.l(s, …, t)`, webpack's script-loading helper). Unknown for any other variable, a
+     * function with no call the code shows, or a call that spreads before it.
+     */
+    private argument;
+    /**
+     * The calls of a function the code shows: an immediate call of it, or a call of the name or member it is bound to
+     * (`n.l = (…) => {…}`, `var f = …`, `function f(…) {…}`) that names it alone.
+     */
+    private callsOf;
+    /** The URL function a callee names: a function bound to a name, or plainly assigned to a member, and nothing else. */
+    private urlFunction;
+    /** The function a callee names: a function bound to a name, or plainly assigned to a member, and nothing else. */
+    private bound;
+    /** The function declaration that declares the variable `key`, named `name`, if one does. */
+    private declared;
+    /**
+     * What each assignment to `object.name` assigns, when `object` is a variable: undefined for a write that isn't a plain
+     * `=`, or undefined for the whole when the object is no variable.
+     */
+    private assigned;
+    private indexMembers;
+}