monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/discovery/lib/scopes.js

@@ -0,0 +1,286 @@
+// Whether code declares a name in scope at a node (§2 Discovery: a worker call is dropped only when a declaration of
+// its root name is in scope at the call). A syntactic scope walk up the node's ancestors, by ECMAScript's scoping rules:
+// `var` and top-level functions belong to the nearest function, static block or program; `let`, `const`, `class` and
+// block-level functions to their block; parameters, a catch clause's parameter, a function expression's and a class's
+// own name to what they enclose. A function's parameter list doesn't see what its body declares. In sloppy code, a
+// block-level function also declares its name in the nearest function or program, as Annex B's block-function hoisting
+// does (§5 post-pass 2). Syntax only.
+/**
+ * A check of whether a declaration of a name is in scope at a node of one program, given `path`, the chain of nodes
+ * from the program down to it, each the parent of the next. The names each scope declares are gathered once.
+ */
+export function scopeCheck(sourceType) {
+    const declared = new Map();
+    return (path, name) => {
+        // Module code is strict, and so is code under a `"use strict"` directive or in a class.
+        let strict = sourceType === 'module';
+        for (let i = 0; i < path.length - 1; i++) {
+            const scope = path[i];
+            const child = path[i + 1];
+            strict ||= becomesStrict(scope, child);
+            const names = namesFor(declared, scope, child, strict);
+            if (names?.has(name))
+                return true;
+        }
+        return false;
+    };
+}
+/** Whether the code under `child` of `node` is strict code though the code around `node` isn't. */
+function becomesStrict(node, child) {
+    switch (node.type) {
+        case 'Program':
+            return hasUseStrict(node['body']);
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression': {
+            const body = node['body'];
+            return child !== node['id'] && body.type === 'BlockStatement' && hasUseStrict(body['body']);
+        }
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            return child !== node['id'];
+        default:
+            return false;
+    }
+}
+/** Whether a program's or function body's directive prologue holds `"use strict"`. */
+function hasUseStrict(statements) {
+    for (const statement of statements) {
+        if (typeof statement['directive'] !== 'string')
+            return false;
+        if (statement['directive'] === 'use strict')
+            return true;
+    }
+    return false;
+}
+/**
+ * The names `scope` declares for the code under its child `child`, or undefined when it declares none there. What a
+ * scope declares for the code it encloses is gathered once.
+ */
+function namesFor(cache, scope, child, strict) {
+    // A function's or class's name, and a switch statement's discriminant, are outside the scope the node makes.
+    if (child === scope['id'] || child === scope['discriminant'])
+        return undefined;
+    // Code in a function's parameter list sees its parameters and a function expression's own name, but not what its body
+    // declares, which gets an environment of its own (ECMAScript FunctionDeclarationInstantiation).
+    if (isFunction(scope) && child !== scope['body'])
+        return new Set(parameterNames(scope));
+    let names = cache.get(scope);
+    if (names === undefined) {
+        const declared = declaredFor(scope, strict);
+        if (declared === undefined)
+            return undefined;
+        cache.set(scope, (names = new Set(declared)));
+    }
+    return names;
+}
+/**
+ * The names a node declares for the code it encloses, if it makes a scope: a function's for its body (its parameter
+ * list sees only `parameterNames`, and a function declaration's own name is its enclosing scope's), a switch
+ * statement's for its case block, a class's for its heritage and body (a class declaration's name is its enclosing
+ * scope's too).
+ */
+function declaredFor(scope, strict) {
+    switch (scope.type) {
+        case 'Program':
+            return varScoped(scope['body'], strict);
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression': {
+            const body = scope['body'];
+            return [
+                ...parameterNames(scope),
+                ...(body.type === 'BlockStatement' ? varScoped(body['body'], strict) : []),
+            ];
+        }
+        case 'StaticBlock':
+            return varScoped(scope['body'], true);
+        case 'BlockStatement':
+            return lexicallyDeclared(scope['body']);
+        case 'SwitchStatement':
+            return lexicallyDeclared(scope['cases'].flatMap((node) => node['consequent']));
+        case 'ForStatement':
+            return lexicalDeclaration(scope['init']);
+        case 'ForInStatement':
+        case 'ForOfStatement':
+            // The loop's `let` or `const` names are in scope, in their temporal dead zone, while its object is evaluated.
+            return lexicalDeclaration(scope['left']);
+        case 'CatchClause':
+            return patternNames(scope['param']);
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            return patternNames(scope['id']);
+        default:
+            return undefined;
+    }
+}
+/** Whether a node is a function, which makes a scope for its parameters and body. */
+function isFunction(node) {
+    return (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression');
+}
+/** The names a function's parameter list and body both see: its parameters, and a function expression's own name. */
+function parameterNames(fn) {
+    return [
+        ...(fn.type === 'FunctionExpression' ? patternNames(fn['id']) : []),
+        ...fn['params'].flatMap(patternNames),
+    ];
+}
+/** The names a variable declaration binds. */
+function declaredNames(declaration) {
+    return declaration['declarations'].flatMap((declarator) => patternNames(declarator['id']));
+}
+/** The names a `let`, `const` or `using` declaration binds, or none for a `var` declaration or anything else. */
+function lexicalDeclaration(node) {
+    if (node?.type !== 'VariableDeclaration' || node['kind'] === 'var')
+        return [];
+    return declaredNames(node);
+}
+/**
+ * The names a statement list declares lexically, as a block's or a case block's does: its `let`, `const` and `using`
+ * declarations, classes and functions, a labelled function included.
+ */
+function lexicallyDeclared(statements) {
+    return statements.flatMap((statement) => {
+        const node = unlabelled(statement);
+        if (node.type === 'VariableDeclaration')
+            return lexicalDeclaration(node);
+        if (node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') {
+            return patternNames(node['id']);
+        }
+        return [];
+    });
+}
+/** The statement a chain of labels labels. */
+function unlabelled(statement) {
+    let node = statement;
+    while (node.type === 'LabeledStatement')
+        node = node['body'];
+    return node;
+}
+/**
+ * The names a function body's, static block's or program's statements declare in its var scope: every declaration at
+ * its top level (a program's imports and exports included), each `var` below it outside nested functions and classes,
+ * and, in sloppy code, each plain function declared in a block below it (Annex B.3.3), unless a `let`, `const`, class
+ * or function of that name in a block between them would clash with a `var` of it.
+ */
+function varScoped(statements, strict) {
+    const names = [];
+    const stack = [];
+    for (const statement of statements) {
+        const node = unlabelled(exported(statement));
+        switch (node.type) {
+            case 'ImportDeclaration':
+                for (const specifier of node['specifiers'])
+                    names.push(...patternNames(specifier['local']));
+                break;
+            case 'VariableDeclaration':
+                names.push(...declaredNames(node));
+                break;
+            case 'FunctionDeclaration':
+            case 'ClassDeclaration':
+                names.push(...patternNames(node['id']));
+                break;
+            default:
+                stack.push({ node, enclosing: [], direct: false });
+        }
+    }
+    for (let item = stack.pop(); item !== undefined; item = stack.pop()) {
+        const { node, enclosing, direct } = item;
+        const push = (child, scope, inList = false) => {
+            if (child === null || child === undefined)
+                return;
+            const inside = scope === undefined ? enclosing : [...enclosing, scope];
+            stack.push({ node: unlabelled(child), enclosing: inside, direct: inList });
+        };
+        switch (node.type) {
+            case 'VariableDeclaration':
+                if (node['kind'] === 'var') {
+                    names.push(...declaredNames(node));
+                }
+                break;
+            case 'FunctionDeclaration': {
+                if (strict || node['generator'] === true || node['async'] === true)
+                    break;
+                const [name] = patternNames(node['id']);
+                // The block the function is declared in declares it lexically; only the blocks outside that one can clash.
+                const between = direct ? enclosing.slice(0, -1) : enclosing;
+                if (name !== undefined && !between.some((scope) => scope.includes(name)))
+                    names.push(name);
+                break;
+            }
+            case 'BlockStatement': {
+                const body = node['body'];
+                const scope = lexicallyDeclared(body);
+                for (const child of body)
+                    push(child, scope, true);
+                break;
+            }
+            case 'IfStatement':
+                push(node['consequent']);
+                push(node['alternate']);
+                break;
+            case 'ForStatement':
+            case 'ForInStatement':
+            case 'ForOfStatement': {
+                const head = (node.type === 'ForStatement' ? node['init'] : node['left']);
+                const scope = lexicalDeclaration(head);
+                if (head?.type === 'VariableDeclaration')
+                    push(head);
+                push(node['body'], scope);
+                break;
+            }
+            case 'WhileStatement':
+            case 'DoWhileStatement':
+            case 'WithStatement':
+                push(node['body']);
+                break;
+            case 'TryStatement': {
+                push(node['block']);
+                const handler = node['handler'];
+                if (handler !== null) {
+                    // A `var` may redeclare a catch clause's plain parameter, but not a destructured one's names (Annex B.3.4).
+                    const param = handler['param'];
+                    push(handler['body'], param === null || param.type === 'Identifier' ? undefined : patternNames(param));
+                }
+                push(node['finalizer']);
+                break;
+            }
+            case 'SwitchStatement': {
+                const consequents = node['cases'].flatMap((node) => node['consequent']);
+                const scope = lexicallyDeclared(consequents);
+                for (const child of consequents)
+                    push(child, scope, true);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return names;
+}
+/** The declaration an `export` statement exports, or the statement itself. */
+function exported(statement) {
+    if (statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration') {
+        const declaration = statement['declaration'];
+        if (declaration !== null)
+            return declaration;
+    }
+    return statement;
+}
+/** The names a binding pattern binds. */
+function patternNames(node) {
+    switch (node?.type) {
+        case 'Identifier':
+            return [node['name']];
+        case 'ObjectPattern':
+            return node['properties'].flatMap((property) => patternNames((property.type === 'RestElement' ? property['argument'] : property['value'])));
+        case 'ArrayPattern':
+            return node['elements'].flatMap(patternNames);
+        case 'AssignmentPattern':
+            return patternNames(node['left']);
+        case 'RestElement':
+            return patternNames(node['argument']);
+        default:
+            return [];
+    }
+}

package/dist/packages/discovery/lib/source-maps.d.ts

@@ -0,0 +1,56 @@
+/** What an artifact's trailing comments name: a source map URL and a debug ID, either possibly absent. */
+export interface Annotations {
+    sourceMappingURL: string | null;
+    debugId: string | null;
+}
+/**
+ * The annotations of an artifact, as ECMA-426 extracts a source map URL without parsing (§ Linking generated code, in
+ * the current draft), with a line scan in place of a lexer: the last `//# sourceMappingURL=` (or `//@`) line comment
+ * that only whitespace and line comments follow, and the same for `//# debugId=`. A line comment that names neither
+ * leaves them. Code resets both, and so does a block comment, which ECMA-426 no longer reads an annotation from. An
+ * empty value names nothing, and resets its annotation. A block comment that runs past its line counts as code.
+ *
+ * With no lexer, a `//` inside a string, a template or a regular expression reads as a comment. So a line comment whose
+ * own text (after the `//`) holds a `"`, `'` or backtick counts as code, as the draft's check has it: it resets both,
+ * whatever its form, and an annotation after it still names (§2 Source maps). An annotation inside a literal is reset,
+ * because a later line closes the literal with a quote, and that line is code or a quoted comment.
+ */
+export declare function annotations(text: string): Annotations;
+/**
+ * The text a `data:` URL holds, decoded as UTF-8 whatever its media type (§17: maps are read as JSON whatever their
+ * type), or null when it is malformed (Fetch § data: URL processor).
+ */
+export declare function dataUrlText(url: URL): string | null;
+/**
+ * The raw JSON of a map's text, with a leading BOM and a `)]}'` first line stripped (ECMA-426 § Fetching source maps),
+ * or undefined when it isn't JSON.
+ */
+export declare function rawMap(text: string): unknown;
+/** The `debugId` of a map's raw JSON, when it has one. */
+export declare function mapDebugId(raw: unknown): string | null;
+/** What a debug ID is compared by: two are equal when they are equal ignoring ASCII case. */
+export declare function debugIdKey(debugId: string): string;
+/**
+ * How an artifact's text is split into lines for its map (§2 Verification): at §5's terminators (`ecmascript`: LF, CR,
+ * CRLF, U+2028 and U+2029), or only at LF and CR (`lf-cr`), which some tools use when the artifact holds a raw U+2028
+ * or U+2029.
+ */
+export type LineReading = 'ecmascript' | 'lf-cr';
+/**
+ * The line reading under which a candidate map verifies against an artifact (§2 Source maps), whatever method found
+ * it, or null when it doesn't verify:
+ *
+ * - the map is `version` 3, and reads as a map (`FlattenMap` flattens a sectioned one)
+ * - every mapped generated line and column exists in the artifact: a column may be the end of its line
+ * - the `debugId`s are equal, ignoring ASCII case, when both sides have one
+ * - the token spot checks pass: no mapped position splits a token of the artifact, which it would when both the code
+ *   units around it are identifier parts
+ *
+ * Lines end at an ECMAScript LineTerminatorSequence (§5 Positions). Tools that split lines only at LF and CR differ
+ * when the artifact holds a raw U+2028 or U+2029, so such an artifact verifies when either reading holds. Attribution
+ * (§10) looks positions up with the reading that verified, and with the LF/CR reading when both do.
+ */
+export declare function verification(artifact: {
+    text: string;
+    debugId: string | null;
+}, raw: unknown): LineReading | null;

package/dist/packages/discovery/lib/source-maps.js

@@ -0,0 +1,209 @@
+// Source-map syntax (§2 Source maps, §19 Discovery): the annotations at the end of an artifact, `data:` URLs, and
+// the verification of a candidate map against the artifact it would pair with. Maps are read with
+// `@jridgewell/trace-mapping` (`FlattenMap`, which flattens a sectioned map), and `debugId` from the raw JSON.
+import { decodedMappings, FlattenMap } from '@jridgewell/trace-mapping';
+/** The comment contents that name a source map URL or a debug ID (ECMA-426 § MatchSourceMapURL, and Debug IDs). */
+const patterns = {
+    sourceMappingURL: /^[@#]\s*sourceMappingURL=(\S*?)\s*$/,
+    debugId: /^[@#]\s*debugId=(\S*?)\s*$/,
+};
+/** ECMAScript WhiteSpace: tab, vertical tab, form feed, ZWNBSP, and every space separator. */
+const whiteSpace = /[\t\v\f\ufeff\p{Zs}]/u;
+/** The code points whose presence in a line comment's own text makes it count as code (ECMA-426, without parsing). */
+const quotes = /["'`]/;
+/**
+ * The annotations of an artifact, as ECMA-426 extracts a source map URL without parsing (§ Linking generated code, in
+ * the current draft), with a line scan in place of a lexer: the last `//# sourceMappingURL=` (or `//@`) line comment
+ * that only whitespace and line comments follow, and the same for `//# debugId=`. A line comment that names neither
+ * leaves them. Code resets both, and so does a block comment, which ECMA-426 no longer reads an annotation from. An
+ * empty value names nothing, and resets its annotation. A block comment that runs past its line counts as code.
+ *
+ * With no lexer, a `//` inside a string, a template or a regular expression reads as a comment. So a line comment whose
+ * own text (after the `//`) holds a `"`, `'` or backtick counts as code, as the draft's check has it: it resets both,
+ * whatever its form, and an annotation after it still names (§2 Source maps). An annotation inside a literal is reset,
+ * because a later line closes the literal with a quote, and that line is code or a quoted comment.
+ */
+export function annotations(text) {
+    const found = { sourceMappingURL: null, debugId: null };
+    /** What a comment names for `key`: its value, null for an empty one, or undefined when it doesn't name `key`. */
+    const match = (comment, key) => {
+        const value = patterns[key].exec(comment)?.[1];
+        return value === undefined ? undefined : value || null;
+    };
+    for (const line of text.split(/\r\n|[\n\r\u2028\u2029]/)) {
+        let position = 0;
+        while (position < line.length) {
+            const first = line[position++];
+            if (whiteSpace.test(first))
+                continue;
+            const second = line[position];
+            if (first === '/' && second === '/') {
+                const comment = line.slice(position + 1);
+                if (quotes.test(comment)) {
+                    found.sourceMappingURL = null;
+                    found.debugId = null;
+                    break;
+                }
+                const url = match(comment, 'sourceMappingURL');
+                const debugId = match(comment, 'debugId');
+                if (url !== undefined)
+                    found.sourceMappingURL = url;
+                if (debugId !== undefined)
+                    found.debugId = debugId;
+                break;
+            }
+            if (first === '/' && second === '*') {
+                found.sourceMappingURL = null;
+                found.debugId = null;
+                // Skipped whole, so that a `//` inside it is not read as a line comment.
+                const end = line.indexOf('*/', position + 1);
+                if (end === -1)
+                    break;
+                position = end + 2;
+                continue;
+            }
+            found.sourceMappingURL = null;
+            found.debugId = null;
+            // Code up to the next `/` would only reset them again.
+            const slash = line.indexOf('/', position);
+            if (slash === -1)
+                break;
+            position = slash;
+        }
+    }
+    return found;
+}
+const decoder = new TextDecoder('utf-8');
+/**
+ * The text a `data:` URL holds, decoded as UTF-8 whatever its media type (§17: maps are read as JSON whatever their
+ * type), or null when it is malformed (Fetch § data: URL processor).
+ */
+export function dataUrlText(url) {
+    // The URL serialized without its fragment, even an empty one, which `url.hash` doesn't show: a serialized URL's first
+    // `#` starts its fragment.
+    const fragment = url.href.indexOf('#');
+    const body = url.href.slice('data:'.length, fragment === -1 ? undefined : fragment);
+    const comma = body.indexOf(',');
+    if (comma === -1)
+        return null;
+    const bytes = percentDecode(body.slice(comma + 1));
+    if (!/;[\t\n\f\r ]*base64[\t\n\f\r ]*$/i.test(body.slice(0, comma)))
+        return decoder.decode(bytes);
+    try {
+        // Base64 is ASCII: any other byte makes `atob` throw.
+        const binary = atob(decoder.decode(bytes).replace(/[\t\n\f\r ]/g, ''));
+        return decoder.decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+    }
+    catch {
+        return null;
+    }
+}
+/** The bytes of a URL component's percent-encoding (URL § percent-decode): an invalid escape is left as it is. */
+function percentDecode(text) {
+    const bytes = [...new TextEncoder().encode(text)];
+    const out = [];
+    for (let i = 0; i < bytes.length; i++) {
+        const hex = String.fromCharCode(bytes[i + 1] ?? 0, bytes[i + 2] ?? 0);
+        if (bytes[i] === 0x25 && /^[0-9a-f]{2}$/i.test(hex)) {
+            out.push(Number.parseInt(hex, 16));
+            i += 2;
+        }
+        else
+            out.push(bytes[i]);
+    }
+    return Uint8Array.from(out);
+}
+/**
+ * The raw JSON of a map's text, with a leading BOM and a `)]}'` first line stripped (ECMA-426 § Fetching source maps),
+ * or undefined when it isn't JSON.
+ */
+export function rawMap(text) {
+    let json = text.startsWith('\ufeff') ? text.slice(1) : text;
+    if (json.startsWith(")]}'"))
+        json = json.slice(json.search(/[\n\r]|$/));
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The `debugId` of a map's raw JSON, when it has one. */
+export function mapDebugId(raw) {
+    return isObject(raw) && typeof raw.debugId === 'string' ? raw.debugId : null;
+}
+/** What a debug ID is compared by: two are equal when they are equal ignoring ASCII case. */
+export function debugIdKey(debugId) {
+    return asciiLowercase(debugId);
+}
+/** The line terminators of each reading. */
+const lineTerminators = {
+    ecmascript: /\r\n|[\n\r\u2028\u2029]/,
+    'lf-cr': /\r\n|[\n\r]/,
+};
+/**
+ * The line reading under which a candidate map verifies against an artifact (§2 Source maps), whatever method found
+ * it, or null when it doesn't verify:
+ *
+ * - the map is `version` 3, and reads as a map (`FlattenMap` flattens a sectioned one)
+ * - every mapped generated line and column exists in the artifact: a column may be the end of its line
+ * - the `debugId`s are equal, ignoring ASCII case, when both sides have one
+ * - the token spot checks pass: no mapped position splits a token of the artifact, which it would when both the code
+ *   units around it are identifier parts
+ *
+ * Lines end at an ECMAScript LineTerminatorSequence (§5 Positions). Tools that split lines only at LF and CR differ
+ * when the artifact holds a raw U+2028 or U+2029, so such an artifact verifies when either reading holds. Attribution
+ * (§10) looks positions up with the reading that verified, and with the LF/CR reading when both do.
+ */
+export function verification(artifact, raw) {
+    if (!isObject(raw) || raw.version !== 3)
+        return null;
+    if ('sections' in raw ? !Array.isArray(raw.sections) : typeof raw.mappings !== 'string')
+        return null;
+    const debugId = mapDebugId(raw);
+    if (debugId !== null && artifact.debugId !== null && debugIdKey(debugId) !== debugIdKey(artifact.debugId)) {
+        return null;
+    }
+    let mapped;
+    try {
+        mapped = decodedMappings(new FlattenMap(raw));
+    }
+    catch {
+        return null;
+    }
+    const readings = /[\u2028\u2029]/.test(artifact.text) ? ['lf-cr', 'ecmascript'] : ['ecmascript'];
+    return readings.find((reading) => positionsHold(artifact.text.split(lineTerminators[reading]), mapped)) ?? null;
+}
+/** Whether every mapped generated position is in `lines`, and starts a token there. */
+function positionsHold(lines, mapped) {
+    for (const [index, segments] of mapped.entries()) {
+        if (segments.length === 0)
+            continue;
+        const line = lines[index];
+        if (line === undefined)
+            return false;
+        for (const [column] of segments) {
+            if (!(column >= 0 && column <= line.length))
+                return false;
+            if (column > 0 && identifierPart(line.charCodeAt(column - 1)) && identifierPart(line.charCodeAt(column))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+const identifierPartPattern = /[$\u200c\u200d\p{ID_Continue}]/u;
+/** Whether a UTF-16 code unit is an identifier part (ECMA-262 IdentifierPartChar). NaN, past the end, is not. */
+function identifierPart(code) {
+    if (Number.isNaN(code))
+        return false;
+    if (code < 0x80) {
+        return (code >= 0x30 && code <= 0x39) || (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a) ||
+            code === 0x24 || code === 0x5f;
+    }
+    return identifierPartPattern.test(String.fromCharCode(code));
+}
+const asciiLowercase = (text) => text.replace(/[A-Z]/g, (letter) => String.fromCharCode(letter.charCodeAt(0) + 32));
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/packages/discovery/lib/swept-code.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A worker marker (§2 Realm): a top-level `importScripts` call, or a `self.addEventListener` call for an `install`,
+ * `fetch` or `message` event, with the call's UTF-16 range.
+ */
+export interface WorkerMarker {
+    marker: 'importScripts' | 'install' | 'fetch' | 'message';
+    start: number;
+    end: number;
+}
+/**
+ * The source type of a file no reference loads, and its worker markers in source order. Its source type comes from its
+ * syntax (`bySyntax`), and code that parses as neither has no markers.
+ */
+export declare function sweptCode(text: string): {
+    sourceType: 'script' | 'module';
+    markers: WorkerMarker[];
+};
+/**
+ * The worker markers in code of the source type `sourceType`, in source order: none when it doesn't parse as that type.
+ */
+export declare function workerMarkersAs(text: string, sourceType: 'script' | 'module'): WorkerMarker[];
+/**
+ * The source type of code no reference says how to load, as a sweep-only file's (§2 Sweep): a `module` when it parses
+ * only as a module, because it holds an `import` or `export` declaration, `import.meta` or a top-level `await`, and a
+ * `script` otherwise. Code that parses as neither is a `script`, which the resolver reports as a `parse-failure`.
+ */
+export declare function sourceTypeBySyntax(text: string): 'script' | 'module';