storm-lua-minify 0.3.0 → 0.9.0

package/dist/functionRewrites.js

@@ -0,0 +1,580 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneTrailingUnusedParameters = pruneTrailingUnusedParameters;
+exports.inlineClosedSingleUseFunctions = inlineClosedSingleUseFunctions;
+exports.inlineLiteralArgumentFunctions = inlineLiteralArgumentFunctions;
+exports.inlineClosedStatementFunctions = inlineClosedStatementFunctions;
+exports.inlineBoundStatementFunctions = inlineBoundStatementFunctions;
+exports.inlineTailCallFunctions = inlineTailCallFunctions;
+const astWalk_1 = require("./astWalk");
+const generatedNode_1 = require("./generatedNode");
+/**
+ * Remove only the trailing, identifier parameters proven unused by Resolve.
+ *
+ * Call arguments deliberately remain untouched: Lua evaluates surplus actuals in
+ * their original order and then discards them, which preserves their effects,
+ * errors, and multiple-value adjustment. A vararg tail is therefore a hard
+ * boundary rather than something this rewrite tries to reason around.
+ */
+function pruneTrailingUnusedParameters(callGraph, metadata, canRewrite = () => true) {
+    let prunedParameters = 0;
+    let prunedMethodParameters = 0;
+    callGraph.functions.forEach((callable) => {
+        if (!canRewrite(callable))
+            return;
+        const declaration = callable.declaration;
+        if (metadata.annotationsOf(declaration).keep)
+            return;
+        let retained = declaration.parameters.length;
+        while (retained > 0) {
+            const parameter = declaration.parameters[retained - 1];
+            if (parameter.type !== "Identifier")
+                break;
+            const symbol = callable.parameters.find((candidate) => candidate.declaration === parameter);
+            if (!symbol || symbol.references.length > 0)
+                break;
+            retained--;
+        }
+        if (retained === declaration.parameters.length)
+            return;
+        const removed = declaration.parameters.length - retained;
+        prunedParameters += removed;
+        if (declaration.identifier?.type === "MemberExpression" &&
+            declaration.identifier.indexer === ":")
+            prunedMethodParameters += removed;
+        declaration.parameters = declaration.parameters.slice(0, retained);
+    });
+    return {
+        changed: prunedParameters > 0,
+        prunedParameters,
+        prunedMethodParameters,
+    };
+}
+function overwriteExpression(target, replacement) {
+    // Visitors dispatch exclusively on `type`; fields from the former node are
+    // inert after this assignment and do not need an unsafe dynamic deletion.
+    Object.assign(target, replacement);
+}
+function isClosedInlineExpression(expression, resolved) {
+    let closed = true;
+    (0, astWalk_1.walkExpression)(expression, {
+        onIdentifierReference: (identifier) => {
+            if (resolved.symbolOf(identifier))
+                closed = false;
+        },
+        onFunction: () => {
+            closed = false;
+        },
+    });
+    return closed;
+}
+function primitiveLiteral(expression) {
+    if (!expression)
+        return { type: "NilLiteral", value: null, raw: "nil" };
+    switch (expression.type) {
+        case "StringLiteral":
+        case "NumericLiteral":
+        case "BooleanLiteral":
+        case "NilLiteral":
+            return expression;
+        default:
+            return undefined;
+    }
+}
+function substituteParameters(expression, replacements) {
+    const clone = structuredClone(expression);
+    const substitute = (original, copied) => {
+        if (original.type !== copied.type)
+            throw new Error("Cloned expression changed node type");
+        switch (original.type) {
+            case "Identifier": {
+                const replacement = replacements.get(original.name);
+                if (replacement)
+                    overwriteExpression(copied, structuredClone(replacement));
+                return;
+            }
+            case "StringLiteral":
+            case "NumericLiteral":
+            case "BooleanLiteral":
+            case "NilLiteral":
+            case "VarargLiteral":
+                return;
+            case "LogicalExpression":
+            case "BinaryExpression": {
+                const binary = copied;
+                substitute(original.left, binary.left);
+                substitute(original.right, binary.right);
+                return;
+            }
+            case "UnaryExpression":
+                substitute(original.argument, copied.argument);
+                return;
+            case "CallExpression": {
+                const call = copied;
+                substitute(original.base, call.base);
+                original.arguments.forEach((argument, index) => {
+                    substitute(argument, call.arguments[index]);
+                });
+                return;
+            }
+            case "TableCallExpression": {
+                const call = copied;
+                substitute(original.base, call.base);
+                substitute(original.arguments, call.arguments);
+                return;
+            }
+            case "StringCallExpression": {
+                const call = copied;
+                substitute(original.base, call.base);
+                substitute(original.argument, call.argument);
+                return;
+            }
+            case "IndexExpression": {
+                const index = copied;
+                substitute(original.base, index.base);
+                substitute(original.index, index.index);
+                return;
+            }
+            case "MemberExpression":
+                substitute(original.base, copied.base);
+                return;
+            case "TableConstructorExpression": {
+                const table = copied;
+                original.fields.forEach((field, index) => {
+                    const copiedField = table.fields[index];
+                    if (field.type === "TableKey") {
+                        if (copiedField.type !== "TableKey")
+                            throw new Error("Cloned table field changed node type");
+                        substitute(field.key, copiedField.key);
+                    }
+                    substitute(field.value, copiedField.value);
+                });
+                return;
+            }
+            case "FunctionDeclaration":
+                throw new Error("Nested functions are not substitutable");
+        }
+    };
+    substitute(expression, clone);
+    return clone;
+}
+function onlyParametersOrGlobals(expression, resolved, parameterNames) {
+    let safe = true;
+    (0, astWalk_1.walkExpression)(expression, {
+        onIdentifierReference: (identifier) => {
+            const symbol = resolved.symbolOf(identifier);
+            if (symbol && !parameterNames.has(symbol.name))
+                safe = false;
+        },
+        onFunction: () => {
+            safe = false;
+        },
+    });
+    return safe;
+}
+/**
+ * Inline the first deliberately narrow class whose binding proof is complete:
+ * a zero-argument, single-use local function returning one closed expression.
+ * Closed means every identifier is global; local/upvalue references wait for
+ * symbol-level alpha conversion instead of being guessed from their spelling.
+ */
+function inlineClosedSingleUseFunctions(analysis, resolved, metadata) {
+    let inlinedFunctions = 0;
+    analysis.callGraph.functions.forEach((callable) => {
+        const declaration = callable.declaration;
+        const symbol = callable.symbol;
+        if (!symbol ||
+            !declaration.isLocal ||
+            declaration.parameters.length !== 0 ||
+            declaration.body.length !== 1 ||
+            symbol.references.length !== 1 ||
+            metadata.annotationsOf(declaration).keep)
+            return;
+        const returned = declaration.body[0];
+        if (returned.type !== "ReturnStatement" || returned.arguments.length !== 1)
+            return;
+        const expression = returned.arguments[0];
+        if (!isClosedInlineExpression(expression, resolved))
+            return;
+        const site = analysis.callGraph.calls.find((candidate) => !candidate.hasUnknownTarget &&
+            candidate.targets.size === 1 &&
+            candidate.targets.has(callable) &&
+            candidate.call.type === "CallExpression" &&
+            candidate.call.arguments.length === 0 &&
+            candidate.call.base === symbol.references[0]);
+        if (!site)
+            return;
+        // structuredClone retains loc/range on every copied node, so the inlined
+        // expression maps to the function body/return origin rather than call-site text.
+        overwriteExpression(site.call, structuredClone(expression));
+        inlinedFunctions++;
+    });
+    return { changed: inlinedFunctions > 0, inlinedFunctions };
+}
+/** Inline a single-return function when every actual is an immutable literal. */
+function inlineLiteralArgumentFunctions(analysis, resolved, metadata) {
+    let inlinedFunctions = 0;
+    analysis.callGraph.functions.forEach((callable) => {
+        const declaration = callable.declaration;
+        const symbol = callable.symbol;
+        if (!symbol ||
+            !declaration.isLocal ||
+            declaration.parameters.length === 0 ||
+            declaration.parameters.some((parameter) => parameter.type !== "Identifier") ||
+            declaration.body.length !== 1 ||
+            symbol.references.length !== 1 ||
+            metadata.annotationsOf(declaration).keep)
+            return;
+        const returned = declaration.body[0];
+        if (returned.type !== "ReturnStatement" || returned.arguments.length !== 1)
+            return;
+        const site = analysis.callGraph.calls.find((candidate) => !candidate.hasUnknownTarget &&
+            candidate.targets.size === 1 &&
+            candidate.targets.has(callable) &&
+            candidate.call.type === "CallExpression" &&
+            candidate.call.arguments.length <= declaration.parameters.length &&
+            candidate.call.base === symbol.references[0]);
+        if (!site || site.call.type !== "CallExpression")
+            return;
+        const replacements = new Map();
+        for (let index = 0; index < declaration.parameters.length; index++) {
+            const parameter = declaration.parameters[index];
+            if (parameter.type !== "Identifier")
+                return;
+            const actual = primitiveLiteral(site.call.arguments[index]);
+            if (!actual)
+                return;
+            replacements.set(parameter.name, actual);
+        }
+        if (!onlyParametersOrGlobals(returned.arguments[0], resolved, new Set(replacements.keys())))
+            return;
+        overwriteExpression(site.call, substituteParameters(returned.arguments[0], replacements));
+        inlinedFunctions++;
+    });
+    return { changed: inlinedFunctions > 0, inlinedFunctions };
+}
+function statementChildren(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "FunctionDeclaration":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        default:
+            return [];
+    }
+}
+function replaceStatement(body, target, replacements) {
+    const index = body.indexOf(target);
+    if (index >= 0) {
+        body.splice(index, 1, ...replacements);
+        return true;
+    }
+    return body.some((statement) => statementChildren(statement).some((child) => replaceStatement(child, target, replacements)));
+}
+function isClosedInlineStatement(statement, resolved) {
+    let closed = true;
+    const inspect = (expression) => {
+        if (!isClosedInlineExpression(expression, resolved))
+            closed = false;
+    };
+    switch (statement.type) {
+        case "AssignmentStatement":
+            statement.variables.forEach(inspect);
+            statement.init.forEach(inspect);
+            return closed;
+        case "CallStatement":
+            inspect(statement.expression);
+            return closed;
+        default:
+            return false;
+    }
+}
+function hasFunctionScopeAncestor(symbolScope, functionScope) {
+    for (let scope = symbolScope; scope; scope = scope.parent) {
+        if (scope === functionScope)
+            return true;
+    }
+    return false;
+}
+function bodyUsesOnlyOwnedBindings(body, resolved, functionScope, allowReturns = false) {
+    let safe = true;
+    const visitBlock = (statements) => {
+        statements.forEach((statement) => {
+            if (statement.type === "FunctionDeclaration") {
+                safe = false;
+                return;
+            }
+            if (statement.type === "ReturnStatement" && !allowReturns) {
+                safe = false;
+                return;
+            }
+            walkStatementForOwnedBindings(statement);
+        });
+    };
+    const walkStatementForOwnedBindings = (statement) => {
+        (0, astWalk_1.walkStatement)(statement, {
+            onIdentifierReference: (identifier) => {
+                const symbol = resolved.symbolOf(identifier);
+                if (symbol && !hasFunctionScopeAncestor(symbol.scope, functionScope))
+                    safe = false;
+            },
+            onFunction: () => {
+                safe = false;
+            },
+            onBlock: visitBlock,
+        });
+    };
+    visitBlock(body);
+    return safe;
+}
+function ownedLocalCount(resolved, functionScope) {
+    return resolved.symbols.filter((symbol) => symbol.kind !== "label" &&
+        hasFunctionScopeAncestor(symbol.scope, functionScope)).length;
+}
+/**
+ * Rename copied callee-owned bindings by resolved symbol identity. This keeps
+ * declarations and references paired even when the call site has same-spelled
+ * locals, and avoids treating field names as lexical bindings.
+ */
+function alphaConvertOwnedCopies(originals, copies, resolved, functionScope) {
+    const owned = new Set(resolved.symbols.filter((symbol) => hasFunctionScopeAncestor(symbol.scope, functionScope)));
+    const unavailable = new Set([
+        ...resolved.symbols.map((symbol) => symbol.name),
+        ...resolved.globals.keys(),
+    ]);
+    const replacementNames = new Map();
+    let nextName = 0;
+    const nameOf = (symbol) => {
+        const existing = replacementNames.get(symbol);
+        if (existing !== undefined)
+            return existing;
+        let candidate;
+        do {
+            candidate = `__stormInline${String(nextName++)}`;
+        } while (unavailable.has(candidate));
+        unavailable.add(candidate);
+        replacementNames.set(symbol, candidate);
+        return candidate;
+    };
+    const visitPair = (original, copy) => {
+        if (!original ||
+            !copy ||
+            typeof original !== "object" ||
+            typeof copy !== "object")
+            return;
+        if (Array.isArray(original)) {
+            if (!Array.isArray(copy))
+                return;
+            original.forEach((value, index) => {
+                visitPair(value, copy[index]);
+            });
+            return;
+        }
+        if (original.type === "Identifier") {
+            if (copy.type !== "Identifier")
+                return;
+            const symbol = resolved.symbolOf(original);
+            if (symbol && owned.has(symbol))
+                copy.name = nameOf(symbol);
+            return;
+        }
+        Object.keys(original).forEach((key) => {
+            visitPair(original[key], copy[key]);
+        });
+    };
+    visitPair(originals, copies);
+}
+/** Inline a straight-line, closed function body at a statement call site. */
+function inlineClosedStatementFunctions(chunk, analysis, resolved, metadata) {
+    let inlinedFunctions = 0;
+    analysis.callGraph.functions.forEach((callable) => {
+        const declaration = callable.declaration;
+        const symbol = callable.symbol;
+        if (!symbol ||
+            !declaration.isLocal ||
+            declaration.parameters.length !== 0 ||
+            symbol.references.length !== 1 ||
+            metadata.annotationsOf(declaration).keep)
+            return;
+        const executable = [...declaration.body];
+        const tail = executable.at(-1);
+        if (tail?.type === "ReturnStatement" && tail.arguments.length === 0)
+            executable.pop();
+        if (executable.length === 0 ||
+            executable.some((statement) => metadata.annotationsOf(statement).keep ||
+                !isClosedInlineStatement(statement, resolved)))
+            return;
+        const site = analysis.callGraph.calls.find((candidate) => candidate.owner.type === "CallStatement" &&
+            candidate.owner.expression === candidate.call &&
+            !candidate.hasUnknownTarget &&
+            candidate.targets.size === 1 &&
+            candidate.targets.has(callable) &&
+            candidate.call.type === "CallExpression" &&
+            candidate.call.arguments.length === 0 &&
+            candidate.call.base === symbol.references[0]);
+        if (!site)
+            return;
+        const replacements = executable.map((statement) => structuredClone(statement));
+        if (!replaceStatement(chunk.body, site.owner, replacements))
+            return;
+        metadata.replaceStatement(site.owner, replacements);
+        executable.forEach((source, index) => {
+            metadata.transferStatements([source], replacements[index]);
+        });
+        inlinedFunctions++;
+    });
+    return { changed: inlinedFunctions > 0, inlinedFunctions };
+}
+/**
+ * Inline a non-returning statement function behind a lexical block and a
+ * parameter-binding local. The binding statement is the semantic boundary:
+ * arbitrary actuals keep Lua's original left-to-right evaluation and tuple
+ * adjustment before the copied body starts.
+ */
+function inlineBoundStatementFunctions(chunk, analysis, resolved, metadata, options) {
+    let inlinedFunctions = 0;
+    analysis.callGraph.functions.forEach((callable) => {
+        const declaration = callable.declaration;
+        const symbol = callable.symbol;
+        const functionScope = resolved.scopeOfFunction(declaration);
+        if (!symbol ||
+            !functionScope ||
+            !declaration.isLocal ||
+            declaration.parameters.length === 0 ||
+            declaration.parameters.some((parameter) => parameter.type !== "Identifier") ||
+            symbol.references.length !== 1 ||
+            metadata.annotationsOf(declaration).keep)
+            return;
+        const executable = [...declaration.body];
+        const tail = executable.at(-1);
+        if (tail?.type === "ReturnStatement" && tail.arguments.length === 0)
+            executable.pop();
+        if (executable.length === 0 ||
+            executable.some((statement) => metadata.annotationsOf(statement).keep) ||
+            !bodyUsesOnlyOwnedBindings(executable, resolved, functionScope))
+            return;
+        const site = analysis.callGraph.calls.find((candidate) => candidate.owner.type === "CallStatement" &&
+            candidate.owner.expression === candidate.call &&
+            !candidate.hasUnknownTarget &&
+            candidate.targets.size === 1 &&
+            candidate.targets.has(callable) &&
+            candidate.call.type === "CallExpression" &&
+            candidate.call.base === symbol.references[0]);
+        if (!site || site.call.type !== "CallExpression")
+            return;
+        if (declaration.parameters.length > options.maxIntroducedLocalsAt(site.owner))
+            return;
+        const binding = {
+            type: "LocalStatement",
+            variables: declaration.parameters.map((parameter) => structuredClone(parameter)),
+            init: site.call.arguments.map((argument) => structuredClone(argument)),
+        };
+        (0, generatedNode_1.copyNodeOrigin)(binding, site.owner);
+        const copiedBody = executable.map((statement) => structuredClone(statement));
+        alphaConvertOwnedCopies([...declaration.parameters, ...executable], [...binding.variables, ...copiedBody], resolved, functionScope);
+        const replacement = {
+            type: "DoStatement",
+            body: [binding, ...copiedBody],
+        };
+        (0, generatedNode_1.copyNodeOrigin)(replacement, site.owner);
+        if (!replaceStatement(chunk.body, site.owner, [replacement]))
+            return;
+        metadata.replaceStatement(site.owner, [replacement]);
+        executable.forEach((source, index) => {
+            metadata.transferStatements([source], copiedBody[index]);
+        });
+        inlinedFunctions++;
+    });
+    return { changed: inlinedFunctions > 0, inlinedFunctions };
+}
+/**
+ * Inline a function into `return f(...)`. Every copied callee return now exits
+ * the caller, which is equivalent specifically because the call occupied the
+ * caller's entire return tuple. A synthetic empty return preserves fallthrough.
+ */
+function inlineTailCallFunctions(chunk, analysis, resolved, metadata, options) {
+    let inlinedFunctions = 0;
+    analysis.callGraph.functions.forEach((callable) => {
+        const declaration = callable.declaration;
+        const symbol = callable.symbol;
+        const functionScope = resolved.scopeOfFunction(declaration);
+        if (!symbol ||
+            !functionScope ||
+            !declaration.isLocal ||
+            declaration.parameters.some((parameter) => parameter.type !== "Identifier") ||
+            declaration.body.length === 0 ||
+            symbol.references.length !== 1 ||
+            metadata.annotationsOf(declaration).keep ||
+            !bodyUsesOnlyOwnedBindings(declaration.body, resolved, functionScope, true))
+            return;
+        const site = analysis.callGraph.calls.find((candidate) => candidate.owner.type === "ReturnStatement" &&
+            candidate.owner.arguments.length === 1 &&
+            candidate.owner.arguments[0] === candidate.call &&
+            !candidate.hasUnknownTarget &&
+            candidate.targets.size === 1 &&
+            candidate.targets.has(callable) &&
+            candidate.call.type === "CallExpression" &&
+            candidate.call.base === symbol.references[0]);
+        if (!site || site.call.type !== "CallExpression")
+            return;
+        const surplusActuals = Math.max(0, site.call.arguments.length - declaration.parameters.length);
+        if (ownedLocalCount(resolved, functionScope) + surplusActuals >
+            options.maxIntroducedLocalsAt(site.owner))
+            return;
+        const body = [];
+        let copiedParameters = [];
+        if (site.call.arguments.length > 0) {
+            copiedParameters = declaration.parameters.map((parameter) => structuredClone(parameter));
+            const unavailable = new Set([
+                ...resolved.symbols.map((candidate) => candidate.name),
+                ...resolved.globals.keys(),
+            ]);
+            while (copiedParameters.length < site.call.arguments.length) {
+                let index = copiedParameters.length;
+                let name = `__stormDiscard${String(index)}`;
+                while (unavailable.has(name)) {
+                    index++;
+                    name = `__stormDiscard${String(index)}`;
+                }
+                unavailable.add(name);
+                copiedParameters.push({ type: "Identifier", name });
+            }
+            const binding = {
+                type: "LocalStatement",
+                variables: copiedParameters,
+                init: site.call.arguments.map((argument) => structuredClone(argument)),
+            };
+            (0, generatedNode_1.copyNodeOrigin)(binding, site.owner);
+            body.push(binding);
+        }
+        const copiedBody = declaration.body.map((statement) => structuredClone(statement));
+        alphaConvertOwnedCopies([...declaration.parameters, ...declaration.body], [
+            ...copiedParameters.slice(0, declaration.parameters.length),
+            ...copiedBody,
+        ], resolved, functionScope);
+        body.push(...copiedBody);
+        if (declaration.body.at(-1)?.type !== "ReturnStatement") {
+            const fallthrough = {
+                type: "ReturnStatement",
+                arguments: [],
+            };
+            (0, generatedNode_1.copyNodeOrigin)(fallthrough, site.owner);
+            body.push(fallthrough);
+        }
+        const replacement = { type: "DoStatement", body };
+        (0, generatedNode_1.copyNodeOrigin)(replacement, site.owner);
+        if (!replaceStatement(chunk.body, site.owner, [replacement]))
+            return;
+        metadata.replaceStatement(site.owner, [replacement]);
+        declaration.body.forEach((source, index) => {
+            metadata.transferStatements([source], copiedBody[index]);
+        });
+        inlinedFunctions++;
+    });
+    return { changed: inlinedFunctions > 0, inlinedFunctions };
+}

package/dist/generatedAst.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRequireWrapperAst = buildRequireWrapperAst;
+const identifier = (name) => ({
+    type: "Identifier",
+    name,
+});
+const member = (base, name) => ({
+    type: "MemberExpression",
+    indexer: ".",
+    identifier: identifier(name),
+    base,
+});
+const index = (base, key) => ({ type: "IndexExpression", base, index: key });
+const loaded = () => member(identifier("package"), "loaded");
+const loadedAtM = () => index(loaded(), identifier("m"));
+const assignment = (variable, value) => ({
+    type: "AssignmentStatement",
+    variables: [variable],
+    init: [value],
+});
+const logical = (operator, left, right) => ({
+    type: "LogicalExpression",
+    operator,
+    left,
+    right,
+});
+const truth = {
+    type: "BooleanLiteral",
+    value: true,
+    raw: "true",
+};
+function moduleClause(moduleName) {
+    const moduleString = {
+        type: "StringLiteral",
+        value: moduleName,
+        raw: JSON.stringify(moduleName),
+    };
+    const moduleBody = { type: "ModuleSplice", moduleName };
+    const loader = {
+        type: "FunctionDeclaration",
+        identifier: null,
+        isLocal: false,
+        parameters: [],
+        // luaparseの公開型は拡張ノードを含まない。コード生成前だけ存在する内部ASTとして
+        // FunctionDeclarationのbodyへ保持し、printer側でModuleSpliceを明示的に処理する。
+        body: [moduleBody],
+    };
+    const callLoader = {
+        type: "CallExpression",
+        base: loader,
+        arguments: [],
+    };
+    return {
+        type: "IfStatement",
+        clauses: [
+            {
+                type: "IfClause",
+                condition: {
+                    type: "BinaryExpression",
+                    operator: "==",
+                    left: identifier("m"),
+                    right: moduleString,
+                },
+                body: [assignment(identifier("r"), callLoader)],
+            },
+        ],
+    };
+}
+/** require互換関数を、入力ソースに由来しない合成ASTとして構築する。 */
+function buildRequireWrapperAst(moduleNames) {
+    const emptyLoadedTable = {
+        type: "TableConstructorExpression",
+        fields: [],
+    };
+    const packageFallback = {
+        type: "TableConstructorExpression",
+        fields: [
+            {
+                type: "TableKeyString",
+                key: identifier("loaded"),
+                value: emptyLoadedTable,
+            },
+        ],
+    };
+    return {
+        type: "FunctionDeclaration",
+        identifier: identifier("require"),
+        isLocal: false,
+        parameters: [identifier("m"), identifier("r")],
+        body: [
+            assignment(identifier("package"), logical("or", identifier("package"), packageFallback)),
+            {
+                type: "IfStatement",
+                clauses: [
+                    {
+                        type: "IfClause",
+                        condition: loadedAtM(),
+                        body: [{ type: "ReturnStatement", arguments: [loadedAtM()] }],
+                    },
+                ],
+            },
+            ...moduleNames.map(moduleClause),
+            assignment(loadedAtM(), logical("or", logical("or", loadedAtM(), identifier("r")), truth)),
+            { type: "ReturnStatement", arguments: [loadedAtM()] },
+        ],
+    };
+}