@flarum/cli 3.0.12 → 3.0.14

package/lib/steps/upgrade/twopointoh/frontend/admin-extender.js

@@ -0,0 +1,842 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const traverse_1 = tslib_1.__importDefault(require("@babel/traverse"));
+const t = tslib_1.__importStar(require("@babel/types"));
+const base_1 = require("../base");
+const ast_1 = require("../../../../utils/ast");
+const babel_ts_1 = require("../../../../utils/babel-ts");
+const composer_1 = require("../../../../utils/composer");
+const TODO = '@TODO: register this with Extend.Admin in admin/extend instead';
+const DOCS = 'https://docs.flarum.org/2.x/extend/admin';
+/**
+ * Flarum 2.0 registers an extension's settings, permissions and page with the
+ * Admin extender, in admin/extend, which is declarative and runs when the admin
+ * mounts, rather than through the registry in an initializer.
+ *
+ * Registrations move only when they would do the same thing from there: each
+ * uses nothing the initializer declares, and nothing else registers with the
+ * registry as the admin boots, since registering later than that would change
+ * their order. Otherwise, all of the extension's registrations stay, with a
+ * @TODO saying why.
+ */
+class AdminExtender extends base_1.BaseUpgradeStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Register admin settings, permissions and pages with Extend.Admin';
+        this.moved = [];
+        this.left = [];
+    }
+    replacements(file) {
+        return /^js\/src\/admin\/index\.(js|jsx|ts|tsx)$/.test(file) ? [(file, code) => this.upgrade(file, code)] : [];
+    }
+    targets() {
+        return ['js/src/admin/index.*'];
+    }
+    gitCommit() {
+        return {
+            message: 'chore(2.0): register admin settings, permissions and pages with Extend.Admin',
+            description: 'Flarum 2.0 registers them with the Admin extender in admin/extend.',
+        };
+    }
+    pauseMessage() {
+        return [
+            this.moved.length > 0 && `The admin settings, permissions and pages are registered with Extend.Admin now, in ${this.moved.join(', ')}.`,
+            this.left.length > 0 && `Some in ${this.left.join(', ')} were left where they are; look for the @TODO comments.`,
+            chalk_1.default.underline(DOCS),
+        ]
+            .filter(Boolean)
+            .join('\n                     ');
+    }
+    async upgrade(file, code) {
+        const ast = (0, babel_ts_1.parse)(code);
+        const program = programOf(ast);
+        const registrations = this.registrations(program);
+        if (registrations.length === 0)
+            return null;
+        let blocked = this.otherRegistryUse(program, registrations, file);
+        const target = blocked ? null : this.target(program, file);
+        if (target && 'reason' in target) {
+            blocked = target.reason;
+        }
+        if (blocked || registrations.some((registration) => registration.reason)) {
+            return this.leave(file, code, registrations, blocked);
+        }
+        return this.move(file, code, program, registrations, target);
+    }
+    /**
+     * The registration chains written as statements of an admin initializer,
+     * `app.initializers.add(name, () => { ... })`.
+     */
+    registrations(program) {
+        const registrations = [];
+        for (const statement of program.get('body')) {
+            const initializer = initializerOf(statement);
+            if (!initializer)
+                continue;
+            for (const inner of initializer.get('body').get('body')) {
+                if (!inner.isExpressionStatement())
+                    continue;
+                const chain = chainOf(inner.node.expression);
+                if (chain) {
+                    registrations.push(this.registration(inner, initializer, chain));
+                }
+            }
+        }
+        return registrations;
+    }
+    registration(statement, initializer, chain) {
+        const registration = {
+            statement,
+            calls: chain.calls,
+            context: null,
+            reason: null,
+            imports: new Map(),
+            constants: new Set(),
+            usesGlobalApp: false,
+        };
+        const because = (reason) => {
+            var _a;
+            (_a = registration.reason) !== null && _a !== void 0 ? _a : (registration.reason = reason);
+        };
+        const forArg = chain.root.arguments[0];
+        if (chain.root.arguments.length === 1 && t.isStringLiteral(forArg)) {
+            registration.context = forArg.value;
+        }
+        else if (chain.root.arguments.length === 1 && t.isIdentifier(forArg)) {
+            const binding = statement.scope.getBinding(forArg.name);
+            const constants = binding && staticConstants(binding);
+            const init = (binding === null || binding === void 0 ? void 0 : binding.path.isVariableDeclarator()) ? binding.path.node.init : null;
+            if (constants && t.isStringLiteral(init)) {
+                registration.context = init.value;
+            }
+        }
+        if (registration.context === null) {
+            because('for() is not given a string the upgrade can read');
+        }
+        for (const call of chain.calls) {
+            const method = call.callee.property;
+            const arity = ARITY[method.name];
+            if (!arity) {
+                because(`it calls ${method.name}(), which Extend.Admin has no equivalent of`);
+            }
+            else if (call.arguments.length < arity[0] || call.arguments.length > arity[1] || call.arguments.some((arg) => !t.isExpression(arg))) {
+                because(`its ${method.name}() is not given the arguments the upgrade expects`);
+            }
+        }
+        const inRoot = (p) => Boolean(p.findParent((parent) => parent.node === chain.root));
+        const appParam = initializer.node.params[0];
+        // Babel's scope has no bindings for these.
+        const types = typeDeclarations(statement.scope.getProgramParent().path.node);
+        const reference = (p) => {
+            if (!p.isReferencedIdentifier() || inRoot(p))
+                return;
+            const name = p.node.name;
+            const binding = p.scope.getBinding(name);
+            if (!binding) {
+                if (types.has(name)) {
+                    because(`it uses ${name}, which this file declares`);
+                    return;
+                }
+                if (name === 'arguments' &&
+                    !p.findParent((parent) => parent.isFunction() && !parent.isArrowFunctionExpression() && parent.isDescendant(statement))) {
+                    because("it uses arguments, which are the initializer's");
+                }
+                if (name === 'app')
+                    registration.usesGlobalApp = true;
+                return;
+            }
+            if (binding.path.isDescendant(statement))
+                return;
+            if (binding.kind === 'param' && binding.path.node === appParam && name === 'app') {
+                registration.usesGlobalApp = true;
+                return;
+            }
+            if (isImport(binding)) {
+                registration.imports.set(name, binding);
+                return;
+            }
+            const constants = binding.scope.path.isProgram() ? staticConstants(binding) : null;
+            if (constants) {
+                constants.forEach((constant) => registration.constants.add(constant));
+                return;
+            }
+            because(`it uses ${name}, which this ${binding.path.isDescendant(initializer) ? 'initializer' : 'file'} declares`);
+        };
+        statement.traverse({
+            ThisExpression(p) {
+                if (!p.findParent((parent) => parent.isFunction() && !parent.isArrowFunctionExpression() && parent.isDescendant(statement))) {
+                    because("it uses this, which is the initializer's");
+                }
+            },
+            Identifier: (p) => reference(p),
+            JSXIdentifier: (p) => reference(p),
+        });
+        // Imports the constants' values use go along with them.
+        for (const constant of registration.constants) {
+            constant.path.traverse({
+                Identifier(p) {
+                    if (!p.isReferencedIdentifier())
+                        return;
+                    const binding = p.scope.getBinding(p.node.name);
+                    if (binding && isImport(binding))
+                        registration.imports.set(binding.identifier.name, binding);
+                },
+            });
+        }
+        return registration;
+    }
+    /**
+     * Why nothing can move because of other code using the registry: in another
+     * admin file, or in this one other than in a registration chain or in a
+     * function that runs later, through extend() or override().
+     */
+    otherRegistryUse(program, registrations, file) {
+        const others = globby_1.default
+            .sync('js/src/admin/**/*.{js,jsx,ts,tsx}', { cwd: this.root })
+            .filter((other) => other !== file)
+            .sort()
+            .find((other) => REGISTRY.test(fs_1.default.readFileSync(path_1.default.join(this.root, other), 'utf8')));
+        if (others)
+            return `${others} uses the registry too`;
+        const statements = new Set(registrations.map((registration) => registration.statement.node));
+        let reason = null;
+        program.traverse({
+            MemberExpression(p) {
+                if (reason || !isRegistry(p.node))
+                    return;
+                const inRegistration = p.findParent((parent) => statements.has(parent.node));
+                const runsLater = p.findParent((parent) => parent.isFunction() && isLaterCallback(parent));
+                if (!inRegistration && !runsLater) {
+                    reason = 'other code in this file uses the registry as it runs';
+                }
+            },
+        });
+        return reason;
+    }
+    /**
+     * Where the extender goes: the admin/extend the index exports, or a new one.
+     */
+    target(program, file) {
+        const lang = path_1.default.extname(file).slice(1);
+        const dir = path_1.default.posix.dirname(file);
+        const existing = ['ts', 'tsx', 'js', 'jsx']
+            .map((ext) => `${dir}/extend.${ext}`)
+            .find((candidate) => fs_1.default.existsSync(path_1.default.join(this.root, candidate)));
+        const exported = program.node.body.filter((node) => {
+            var _a;
+            return (t.isExportNamedDeclaration(node) &&
+                (node.specifiers.some((specifier) => t.isExportSpecifier(specifier) && exportedName(specifier) === 'extend') ||
+                    (t.isVariableDeclaration(node.declaration) && node.declaration.declarations.some((d) => t.isIdentifier(d.id, { name: 'extend' }))) ||
+                    (t.isFunctionDeclaration(node.declaration) && ((_a = node.declaration.id) === null || _a === void 0 ? void 0 : _a.name) === 'extend'))) ||
+                t.isExportAllDeclaration(node);
+        });
+        const reexport = exported.find((node) => t.isExportNamedDeclaration(node) && node.source !== null && node.source !== undefined);
+        if (exported.some((node) => !t.isExportAllDeclaration(node) && node !== reexport)) {
+            return { reason: 'the index exports its extenders itself' };
+        }
+        if (!reexport) {
+            if (existing) {
+                return { reason: `${existing} exists, but the index does not export it` };
+            }
+            return { file: `${dir}/extend.${lang}`, existing: null, common: null };
+        }
+        const source = reexport.source.value;
+        const specifier = reexport.specifiers.find((s) => t.isExportSpecifier(s) && exportedName(s) === 'extend');
+        if (!t.isIdentifier(specifier.local, { name: 'default' })) {
+            return { reason: 'the index exports something other than a default export as extend' };
+        }
+        if (source.startsWith('./')) {
+            const resolved = ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', '/index.jsx']
+                .map((suffix) => path_1.default.posix.join(dir, source + suffix))
+                .find((candidate) => fs_1.default.existsSync(path_1.default.join(this.root, candidate)) && fs_1.default.statSync(path_1.default.join(this.root, candidate)).isFile());
+            if (!resolved) {
+                return { reason: `the index exports extend from ${source}, which the upgrade could not find` };
+            }
+            return { file: resolved, existing: fs_1.default.readFileSync(path_1.default.join(this.root, resolved), 'utf8'), common: null };
+        }
+        if (existing) {
+            return { reason: `${existing} exists, but the index exports ${source} instead` };
+        }
+        if (reexport.specifiers.length > 1) {
+            return { reason: `the index exports more than extend from ${source}` };
+        }
+        return { file: `${dir}/extend.${lang}`, existing: null, common: { source, declaration: reexport } };
+    }
+    leave(file, code, registrations, blocked) {
+        var _a, _b, _c;
+        const edits = [];
+        for (const registration of registrations) {
+            const node = registration.statement.node;
+            if ((_a = node.leadingComments) === null || _a === void 0 ? void 0 : _a.some((comment) => comment.value.includes(TODO)))
+                continue;
+            const reason = (_c = (_b = registration.reason) !== null && _b !== void 0 ? _b : blocked) !== null && _c !== void 0 ? _c : 'another registration in this file cannot move, and moving only some would change their order';
+            const lineStart = code.lastIndexOf('\n', node.start - 1) + 1;
+            const indent = code.slice(lineStart, node.start);
+            edits.push({ start: lineStart, end: lineStart, text: `${indent}// ${TODO} (${DOCS}). The upgrade left it here because ${reason}.\n` });
+        }
+        if (edits.length === 0)
+            return null;
+        this.left.push(file);
+        return { updated: applyEdits(code, edits) };
+    }
+    async move(file, code, program, registrations, target) {
+        const id = this.extensionId();
+        const existing = target.existing === null ? null : parseExtend(target.existing);
+        if (existing && 'reason' in existing) {
+            return this.leave(file, code, registrations, `${target.file} ${existing.reason}`);
+        }
+        // What the extend file needs from the index.
+        const imports = new Map();
+        const constants = new Set();
+        let usesGlobalApp = false;
+        for (const registration of registrations) {
+            registration.imports.forEach((binding, name) => imports.set(name, binding));
+            registration.constants.forEach((constant) => constants.add(constant));
+            usesGlobalApp || (usesGlobalApp = registration.usesGlobalApp && !registration.imports.has('app'));
+        }
+        const needed = [defaultImport('Extend', 'flarum/common/extenders')];
+        if (target.common) {
+            needed.push(defaultImport('commonExtend', target.common.source));
+        }
+        if (usesGlobalApp && !imports.has('app')) {
+            needed.push(defaultImport('app', 'flarum/admin/app'));
+        }
+        needed.push(...importsNeeded(imports));
+        const constantDeclarations = [...constants].sort((a, b) => a.path.node.start - b.path.node.start);
+        for (const constant of constantDeclarations) {
+            const declarator = constant.path.node;
+            needed.push({ name: constant.identifier.name, text: `const ${slice(code, declarator)};`, kind: 'const' });
+        }
+        // Each name once, and not one the extend file uses for something else.
+        const missing = [];
+        for (const need of needed) {
+            const twin = needed.find((other) => other !== need && other.name === need.name);
+            if (twin && !sameBinding(twin, need)) {
+                return this.leave(file, code, registrations, `admin/extend would need two different things named ${need.name}`);
+            }
+            const has = existing === null || existing === void 0 ? void 0 : existing.bindings.get(need.name);
+            if (has && !sameBinding(has, need)) {
+                return this.leave(file, code, registrations, `${target.file} already uses the name ${need.name}`);
+            }
+            if (!has && !missing.some((other) => other.name === need.name)) {
+                missing.push(need);
+            }
+        }
+        const importLines = printImports(missing, code);
+        const constantLines = missing.filter((need) => need.kind === 'const').map((need) => need.text);
+        // The extenders, one for each extension named, in the order they appear.
+        const contexts = [];
+        for (const registration of registrations) {
+            if (!contexts.includes(registration.context))
+                contexts.push(registration.context);
+        }
+        const extenders = contexts.map((context) => {
+            const args = context === id ? '' : `'${context.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+            return (`new Extend.Admin(${args})` +
+                registrations
+                    .filter((registration) => registration.context === context)
+                    .map((registration) => methods(registration, code))
+                    .join(''));
+        });
+        const extendCode = existing
+            ? appendTo(target.existing, existing, importLines, constantLines, extenders)
+            : newExtend(importLines, constantLines, extenders, Boolean(target.common));
+        const index = indexEdits(code, program, registrations, imports, constants, target);
+        this.moved.push(target.file);
+        return {
+            updated: index,
+            newFiles: [{ path: target.file, code: await (0, ast_1.formatCode)(extendCode) }],
+        };
+    }
+    /** The extension's ID, as core makes it from the package name. */
+    extensionId() {
+        try {
+            return (0, composer_1.extensionId)(JSON.parse(fs_1.default.readFileSync(path_1.default.join(this.root, 'composer.json'), 'utf8')).name);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+}
+exports.default = AdminExtender;
+/** The arguments each registry method takes, at least and at most. */
+const ARITY = {
+    registerSetting: [1, 2],
+    registerPermission: [2, 3],
+    registerPage: [1, 1],
+};
+const REGISTRY = /\bapp\.(extensionData|registry)\b/;
+function programOf(ast) {
+    let program = null;
+    (0, traverse_1.default)(ast, {
+        Program(p) {
+            program = p;
+            p.stop();
+        },
+    });
+    return program;
+}
+const slice = (code, node) => code.slice(node.start, node.end);
+const isApp = (node) => t.isIdentifier(node, { name: 'app' });
+function isRegistry(node) {
+    return isApp(node.object) && !node.computed && t.isIdentifier(node.property) && ['extensionData', 'registry'].includes(node.property.name);
+}
+/** The callback of `app.initializers.add(name, callback)`, when it has a body. */
+function initializerOf(statement) {
+    if (!statement.isExpressionStatement())
+        return null;
+    const call = statement.get('expression');
+    if (!call.isCallExpression())
+        return null;
+    const callee = call.node.callee;
+    if (!t.isMemberExpression(callee) ||
+        !t.isIdentifier(callee.property, { name: 'add' }) ||
+        !t.isMemberExpression(callee.object) ||
+        !isApp(callee.object.object) ||
+        !t.isIdentifier(callee.object.property, { name: 'initializers' })) {
+        return null;
+    }
+    const callback = call.get('arguments')[1];
+    if (!callback || !(callback.isArrowFunctionExpression() || callback.isFunctionExpression()) || !t.isBlockStatement(callback.node.body)) {
+        return null;
+    }
+    return callback;
+}
+/** `app.extensionData.for(...).registerX(...)...`, or app.registry's. */
+function chainOf(expression) {
+    const calls = [];
+    let node = expression;
+    while (t.isCallExpression(node) && t.isMemberExpression(node.callee) && !node.callee.computed && t.isIdentifier(node.callee.property)) {
+        const object = node.callee.object;
+        if (node.callee.property.name === 'for' && t.isMemberExpression(object) && isRegistry(object)) {
+            return calls.length > 0 ? { root: node, calls: calls.reverse() } : null;
+        }
+        calls.push(node);
+        node = object;
+    }
+    return null;
+}
+/** The names of the types, interfaces, enums and namespaces a file declares. */
+function typeDeclarations(program) {
+    const names = new Set();
+    for (const node of program.body) {
+        const declaration = t.isExportNamedDeclaration(node) ? node.declaration : node;
+        if ((t.isTSInterfaceDeclaration(declaration) ||
+            t.isTSTypeAliasDeclaration(declaration) ||
+            t.isTSEnumDeclaration(declaration) ||
+            t.isTSModuleDeclaration(declaration)) &&
+            t.isIdentifier(declaration.id)) {
+            names.add(declaration.id.name);
+        }
+    }
+    return names;
+}
+function isImport(binding) {
+    return binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier();
+}
+/**
+ * A module-level constant whose value is fixed, with the constants its value
+ * uses: those can be copied as they are.
+ */
+function staticConstants(binding, seen = new Set()) {
+    if (seen.has(binding))
+        return seen;
+    if (binding.kind !== 'const' || !binding.path.isVariableDeclarator() || !binding.scope.path.isProgram() || !binding.path.node.init) {
+        return null;
+    }
+    seen.add(binding);
+    const init = binding.path.get('init');
+    return isStatic(init, seen) ? seen : null;
+}
+function isStatic(p, seen) {
+    const node = p.node;
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node))
+        return true;
+    if (t.isTemplateLiteral(node))
+        return p.get('expressions').every((expression) => isStatic(expression, seen));
+    if (t.isBinaryExpression(node))
+        return isStatic(p.get('left'), seen) && isStatic(p.get('right'), seen);
+    if (t.isUnaryExpression(node))
+        return isStatic(p.get('argument'), seen);
+    if (t.isTSAsExpression(node) || t.isParenthesizedExpression(node))
+        return isStatic(p.get('expression'), seen);
+    if (t.isIdentifier(node)) {
+        const binding = p.scope.getBinding(node.name);
+        return Boolean(binding && staticConstants(binding, seen));
+    }
+    return false;
+}
+/** A function given to extend() or override(), which runs when the extended method does. */
+function isLaterCallback(fn) {
+    const call = fn.parentPath;
+    if (!(call === null || call === void 0 ? void 0 : call.isCallExpression()) || fn.listKey !== 'arguments' || !t.isIdentifier(call.node.callee))
+        return false;
+    const binding = call.scope.getBinding(call.node.callee.name);
+    if (!binding || !binding.path.isImportSpecifier())
+        return false;
+    const declaration = binding.path.parent;
+    const imported = binding.path.node.imported;
+    const importedName = t.isIdentifier(imported) ? imported.name : imported.value;
+    return /(^|\/)extend$/.test(declaration.source.value) && ['extend', 'override'].includes(importedName);
+}
+const exportedName = (specifier) => (t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value);
+/** The extender methods for a registration's calls, with the comments among them. */
+function methods(registration, code) {
+    var _a;
+    const node = registration.statement.node;
+    const parent = registration.statement.parentPath.node;
+    const previous = parent.body[parent.body.indexOf(node) - 1];
+    // Comments above the statement, but not one ending the line before it.
+    const leading = ((_a = node.leadingComments) !== null && _a !== void 0 ? _a : []).filter((comment) => !previous || comment.loc.start.line > previous.loc.end.line);
+    const argRanges = registration.calls.flatMap((call) => call.arguments.map((arg) => [arg.start, arg.end]));
+    const inArgs = (comment) => argRanges.some(([start, end]) => comment.start >= start && comment.end <= end);
+    let text = '';
+    registration.calls.forEach((call, i) => {
+        const start = i === 0 ? node.start : registration.calls[i - 1].end;
+        const comments = [...(i === 0 ? leading : []), ...commentsIn(start, call.end, node).filter((comment) => !inArgs(comment))];
+        text += comments.map((comment) => '\n' + printComment(comment)).join('') + '\n';
+        text += method(call, code);
+    });
+    // Ones after the last call, before the semicolon.
+    const last = registration.calls[registration.calls.length - 1];
+    for (const comment of commentsIn(last.end, node.end, node)) {
+        text += ' ' + printComment(comment) + (comment.type === 'CommentLine' ? '\n' : '');
+    }
+    return text;
+}
+const printComment = (comment) => (comment.type === 'CommentLine' ? `//${comment.value}` : `/*${comment.value}*/`);
+/** The comments the statement's own source has between two offsets. */
+function commentsIn(start, end, statement) {
+    const all = [];
+    t.traverseFast(statement, (node) => {
+        var _a, _b, _c;
+        for (const comment of [...((_a = node.leadingComments) !== null && _a !== void 0 ? _a : []), ...((_b = node.innerComments) !== null && _b !== void 0 ? _b : []), ...((_c = node.trailingComments) !== null && _c !== void 0 ? _c : [])]) {
+            if (comment.start >= start && comment.end <= end && !all.some((c) => c.start === comment.start))
+                all.push(comment);
+        }
+    });
+    return all.sort((a, b) => a.start - b.start);
+}
+function method(call, code) {
+    const name = call.callee.property.name;
+    const [first, ...rest] = call.arguments.map((arg) => slice(code, arg));
+    const more = rest.map((arg) => `, ${arg}`).join('');
+    switch (name) {
+        case 'registerSetting':
+            return t.isFunction(call.arguments[0]) ? `.customSetting(${first}${more})` : `.setting(() => (${first})${more})`;
+        case 'registerPermission':
+            return `.permission(() => (${first})${more})`;
+        default:
+            return `.page(${first})`;
+    }
+}
+/** What the extend file needs from the index's imports, in the index's order. */
+function importsNeeded(imports) {
+    return [...imports.values()]
+        .sort((a, b) => a.path.node.start - b.path.node.start)
+        .map((binding) => {
+        const declaration = binding.path.parent;
+        const specifier = binding.path.node;
+        return {
+            name: specifier.local.name,
+            kind: 'import',
+            source: declaration.source.value,
+            imported: importedOf(specifier),
+            typeOnly: isTypeOnly(declaration, specifier),
+            declaration,
+            specifier,
+        };
+    });
+}
+function defaultImport(name, source) {
+    return { name, kind: 'import', source, imported: 'default', typeOnly: false, text: `import ${name} from '${source}';` };
+}
+const isTypeOnly = (declaration, specifier) => declaration.importKind === 'type' || (t.isImportSpecifier(specifier) && specifier.importKind === 'type');
+/** The import lines for what is missing: the index's imports keep their declarations, with only the names needed. */
+function printImports(missing, code) {
+    const order = [];
+    const specifiers = new Map();
+    for (const need of missing) {
+        if (need.kind !== 'import')
+            continue;
+        if (need.text) {
+            order.push(need.text);
+        }
+        else if (specifiers.has(need.declaration)) {
+            specifiers.get(need.declaration).push(need.specifier);
+        }
+        else {
+            specifiers.set(need.declaration, [need.specifier]);
+            order.push(need.declaration);
+        }
+    }
+    return order.map((line) => (typeof line === 'string' ? line : printImport(line, specifiers.get(line), code)));
+}
+function importedOf(specifier) {
+    if (t.isImportDefaultSpecifier(specifier))
+        return 'default';
+    if (t.isImportNamespaceSpecifier(specifier))
+        return '*';
+    return t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+}
+function printImport(declaration, specifiers, code) {
+    const parts = [];
+    const named = [];
+    for (const specifier of specifiers) {
+        if (t.isImportDefaultSpecifier(specifier)) {
+            parts.unshift(specifier.local.name);
+        }
+        else if (t.isImportNamespaceSpecifier(specifier)) {
+            parts.push(`* as ${specifier.local.name}`);
+        }
+        else {
+            const imported = importedOf(specifier);
+            const type = specifier.importKind === 'type' ? 'type ' : '';
+            const name = t.isIdentifier(specifier.imported) ? imported : `'${imported}'`;
+            named.push(`${type}${name}${imported === specifier.local.name ? '' : ` as ${specifier.local.name}`}`);
+        }
+    }
+    if (named.length > 0)
+        parts.push(`{ ${named.join(', ')} }`);
+    const type = declaration.importKind === 'type' ? 'type ' : '';
+    return `import ${type}${parts.join(', ')} from ${slice(code, declaration.source)};`;
+}
+/** The extend file the extension has: its exported array, and the names it binds. */
+function parseExtend(code) {
+    let ast;
+    try {
+        ast = (0, babel_ts_1.parse)(code);
+    }
+    catch (_a) {
+        return { reason: 'could not be parsed' };
+    }
+    const exported = ast.program.body.find((node) => t.isExportDefaultDeclaration(node));
+    if (!exported || !t.isArrayExpression(exported.declaration)) {
+        return { reason: 'does not export an array the upgrade can add to' };
+    }
+    const bindings = new Map();
+    let lastImportEnd = null;
+    for (const node of ast.program.body) {
+        if (t.isImportDeclaration(node)) {
+            lastImportEnd = node.end;
+            for (const specifier of node.specifiers) {
+                bindings.set(specifier.local.name, {
+                    name: specifier.local.name,
+                    kind: 'import',
+                    source: node.source.value,
+                    imported: importedOf(specifier),
+                    typeOnly: isTypeOnly(node, specifier),
+                });
+            }
+            continue;
+        }
+        const declaration = t.isExportNamedDeclaration(node) ? node.declaration : node;
+        if (t.isVariableDeclaration(declaration)) {
+            for (const declarator of declaration.declarations) {
+                if (t.isIdentifier(declarator.id)) {
+                    bindings.set(declarator.id.name, { name: declarator.id.name, text: `${declaration.kind} ${slice(code, declarator)};`, kind: 'const' });
+                }
+            }
+        }
+        else if ((t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) && declaration.id) {
+            bindings.set(declaration.id.name, { name: declaration.id.name, text: slice(code, declaration), kind: 'const' });
+        }
+    }
+    return { ast, array: exported.declaration, bindings, lastImportEnd };
+}
+/** Whether what the file has will do for what is needed: a type-only import will not do for a value. */
+function sameBinding(has, need) {
+    if (has.kind === 'import' && need.kind === 'import') {
+        return has.source === need.source && has.imported === need.imported && (need.typeOnly || !has.typeOnly);
+    }
+    return has.kind === need.kind && has.text === need.text;
+}
+function newExtend(imports, constants, extenders, common) {
+    const elements = [...(common ? ['...commonExtend'] : []), ...extenders];
+    return [imports.join('\n'), constants.join('\n'), `export default [\n${elements.join(',\n\n')},\n];\n`].filter(Boolean).join('\n\n');
+}
+function appendTo(code, existing, imports, constants, extenders) {
+    var _a;
+    const edits = [];
+    const head = [imports.join('\n'), constants.length > 0 ? '\n' + constants.join('\n') : ''].filter(Boolean).join('\n');
+    if (head) {
+        const at = (_a = existing.lastImportEnd) !== null && _a !== void 0 ? _a : 0;
+        edits.push({ start: at, end: at, text: existing.lastImportEnd === null ? head + '\n\n' : '\n' + head });
+    }
+    // After what the array has, comments included, with a blank line after an element.
+    const elements = existing.array.elements;
+    const last = elements[elements.length - 1];
+    const open = last ? last.end : existing.array.start + 1;
+    const close = existing.array.end - 1;
+    const between = code.slice(open, close).replace(/\s+$/, '');
+    const comma = last && !between.replace(/\/\/[^\n]*|\/\*[\S\s]*?\*\//g, '').includes(',') ? ',' : '';
+    const gap = last && !/(\/\/[^\n]*|\*\/)$/.test(between) ? '\n\n' : '\n';
+    edits.push({ start: open, end: close, text: comma + between + gap + extenders.join(',\n\n') + ',\n' });
+    return applyEdits(code, edits);
+}
+/** The index without the moved registrations and what only they used, exporting extend. */
+function indexEdits(code, program, registrations, imports, constants, target) {
+    var _a;
+    const edits = [];
+    const moved = new Set(registrations.map((registration) => registration.statement.node));
+    const emptied = emptiedInitializers(registrations, moved);
+    // An initializer left with nothing to do goes as a whole. 2.0 checks
+    // whether an extension is enabled in flarum.extensions, not by its
+    // initializer, so nothing needs it to stay.
+    // The app it added itself to may now go unused too.
+    const candidates = new Map(imports);
+    for (const initializer of emptied) {
+        moved.add(initializer.node);
+        edits.push(removal(code, initializer));
+        const app = initializer.get('expression.callee.object.object');
+        const binding = app.isIdentifier() ? app.scope.getBinding(app.node.name) : undefined;
+        if (binding && isImport(binding))
+            candidates.set(binding.identifier.name, binding);
+    }
+    for (const registration of registrations) {
+        if (!emptied.some((initializer) => registration.statement.isDescendant(initializer))) {
+            edits.push(removal(code, registration.statement));
+        }
+    }
+    // A constant only the moved code, or another constant going, used goes too.
+    const going = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const constant of constants) {
+            if (going.has(constant) || isExported(constant))
+                continue;
+            const used = constant.referencePaths.some((reference) => !reference.findParent((parent) => moved.has(parent.node) || [...going].some((other) => other.path.node === parent.node)));
+            if (!used) {
+                going.add(constant);
+                changed = true;
+            }
+        }
+    }
+    // The for() names a constant as well.
+    for (const registration of registrations) {
+        const forArg = chainRoot(registration).arguments[0];
+        if (t.isIdentifier(forArg)) {
+            const binding = registration.statement.scope.getBinding(forArg.name);
+            if (binding && !isImport(binding) && !isExported(binding) && !going.has(binding)) {
+                const used = binding.referencePaths.some((reference) => !reference.findParent((parent) => moved.has(parent.node)));
+                if (!used)
+                    going.add(binding);
+            }
+        }
+    }
+    for (const constant of going) {
+        const declaration = constant.path.parentPath;
+        const remaining = declaration.node.declarations.filter((declarator) => ![...going].some((other) => other.path.node === declarator));
+        edits.push(remaining.length === 0
+            ? wholeLines(code, declaration.node)
+            : {
+                start: declaration.node.start,
+                end: declaration.node.end,
+                text: `${declaration.node.kind} ${remaining.map((d) => slice(code, d)).join(', ')};`,
+            });
+    }
+    // An import only the moved code, or constants going, used.
+    const outside = (reference) => !reference.findParent((parent) => moved.has(parent.node) || [...going].some((g) => g.path.parentPath.node === parent.node));
+    const byDeclaration = new Map();
+    for (const binding of candidates.values()) {
+        if (references(program, binding).some(outside))
+            continue;
+        const declaration = binding.path.parent;
+        byDeclaration.set(declaration, [...((_a = byDeclaration.get(declaration)) !== null && _a !== void 0 ? _a : []), binding.path.node]);
+    }
+    const removedImports = new Set();
+    for (const [declaration, unused] of byDeclaration) {
+        const remaining = declaration.specifiers.filter((specifier) => !unused.includes(specifier));
+        if (remaining.length === 0) {
+            removedImports.add(declaration);
+            edits.push(wholeLines(code, declaration));
+        }
+        else {
+            edits.push({ start: declaration.start, end: declaration.end, text: printImport(declaration, remaining, code) });
+        }
+    }
+    // Export extend from the new file.
+    if (target.common) {
+        const source = target.common.declaration.source;
+        edits.push({ start: source.start, end: source.end, text: "'./extend'" });
+    }
+    else if (target.existing === null) {
+        const lastImport = [...program.node.body].reverse().find((node) => t.isImportDeclaration(node) && !removedImports.has(node));
+        const line = "export { default as extend } from './extend';";
+        edits.push(lastImport ? { start: lastImport.end, end: lastImport.end, text: `\n\n${line}` } : { start: 0, end: 0, text: `${line}\n\n` });
+    }
+    return applyEdits(code, edits);
+}
+const chainRoot = (registration) => registration.calls[0].callee.object;
+function isExported(binding) {
+    var _a, _b;
+    return Boolean((_b = (_a = binding.path.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath) === null || _b === void 0 ? void 0 : _b.isExportNamedDeclaration());
+}
+/** Every reference to a binding, including in types, which Babel does not count. */
+function references(program, binding) {
+    const found = [];
+    const visit = (p) => {
+        if (p.isReferencedIdentifier() && p.scope.getBinding(p.node.name) === binding)
+            found.push(p);
+    };
+    program.traverse({ Identifier: visit, JSXIdentifier: visit });
+    return found;
+}
+/**
+ * The `app.initializers.add(...)` statements that only held registrations
+ * which are moving, and no comments of their own.
+ */
+function emptiedInitializers(registrations, moved) {
+    var _a, _b, _c, _d, _e;
+    const emptied = [];
+    for (const registration of registrations) {
+        const block = registration.statement.parentPath;
+        const statement = (_b = (_a = block.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath) === null || _b === void 0 ? void 0 : _b.parentPath;
+        if (!(statement === null || statement === void 0 ? void 0 : statement.isExpressionStatement()) || emptied.some((other) => other.node === statement.node))
+            continue;
+        const body = block.node.body;
+        const removed = new Set(body.flatMap((node) => { var _a; return (_a = node.leadingComments) !== null && _a !== void 0 ? _a : []; }));
+        const kept = [...((_c = block.node.innerComments) !== null && _c !== void 0 ? _c : []), ...((_e = (_d = body.at(-1)) === null || _d === void 0 ? void 0 : _d.trailingComments) !== null && _e !== void 0 ? _e : [])].filter((comment) => !removed.has(comment));
+        if (body.every((node) => moved.has(node)) && kept.length === 0) {
+            emptied.push(statement);
+        }
+    }
+    return emptied;
+}
+/** The statement's lines, with the comments above it and one ending its line. */
+function removal(code, statement) {
+    var _a;
+    const node = statement.node;
+    const parent = statement.parentPath.node;
+    const previous = parent.body[parent.body.indexOf(node) - 1];
+    const leading = ((_a = node.leadingComments) !== null && _a !== void 0 ? _a : []).filter((comment) => !previous || comment.loc.start.line > previous.loc.end.line);
+    const start = leading.length > 0 ? leading[0].start : node.start;
+    return wholeLines(code, { start, end: node.end });
+}
+/** A node's lines, when nothing else is on them; otherwise just the node. */
+function wholeLines(code, node) {
+    const lineStart = code.lastIndexOf('\n', node.start - 1) + 1;
+    const lineEnd = code.indexOf('\n', node.end);
+    const end = lineEnd === -1 ? code.length : lineEnd + 1;
+    const before = code.slice(lineStart, node.start);
+    const after = code.slice(node.end, end);
+    if (before.trim() === '' && after.trim() === '') {
+        return { start: lineStart, end, text: '' };
+    }
+    return { start: node.start, end: node.end, text: '' };
+}
+function applyEdits(code, edits) {
+    const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+    for (let i = 1; i < sorted.length; i++) {
+        if (sorted[i].end > sorted[i - 1].start && sorted[i].start !== sorted[i].end) {
+            throw new Error('The upgrade tried to change the same code twice.');
+        }
+    }
+    return sorted.reduce((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), code);
+}