@strapi/strapi 5.12.0 → 5.12.2

package/dist/chunks/index-DL_emYoN.mjs

@@ -1,3160 +0,0 @@
-import { createCommand, Option, InvalidOptionArgumentError, Command } from 'commander';
-import { buildStrapiCloudCommands } from '@strapi/cloud-cli';
-import { yup, machineID, errors, env, strings } from '@strapi/utils';
-import _ from 'lodash';
-import inquirer from 'inquirer';
-import { compileStrapi, createStrapi } from '@strapi/core';
-import chalk from 'chalk';
-import { isString, isArray, has, toUpper, isNaN, merge, isObject, isFinite, toNumber } from 'lodash/fp';
-import boxen from 'boxen';
-import CLITable from 'cli-table3';
-import fs from 'fs';
-import path$1, { resolve } from 'path';
-import fse from 'fs-extra';
-import { randomUUID } from 'crypto';
-import * as tsUtils from '@strapi/typescript-utils';
-import tsUtils__default from '@strapi/typescript-utils';
-import os from 'node:os';
-import fs$1, { access } from 'node:fs/promises';
-import path from 'node:path';
-import semver from 'semver';
-import resolveFrom from 'resolve-from';
-import execa from 'execa';
-import readPkgUp from 'read-pkg-up';
-import { performance } from 'perf_hooks';
-import browserslist from 'browserslist';
-import dotenv from 'dotenv';
-import { register } from 'esbuild-register/dist/node';
-import fs$2 from 'node:fs';
-import camelCase from 'lodash/camelCase';
-import outdent from 'outdent';
-import { createElement } from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { DefaultDocument } from '@strapi/admin/_internal';
-import REPL from 'repl';
-import cluster from 'node:cluster';
-import chokidar from 'chokidar';
-import os$1, { EOL } from 'os';
-import { createLogger as createLogger$1, configs, formats } from '@strapi/logger';
-import ora from 'ora';
-import { engine, file, strapi as strapi$1 } from '@strapi/data-transfer';
-import * as cliProgress from 'cli-progress';
-import ts from 'typescript';
-
-/**
- * Helper functions for the Strapi CLI
- */ const bytesPerKb = 1024;
-const sizes = [
-    'B ',
-    'KB',
-    'MB',
-    'GB',
-    'TB',
-    'PB'
-];
-/**
- * Convert bytes to a human readable formatted string, for example "1024" becomes "1KB"
- */ const readableBytes = (bytes, decimals = 1, padStart = 0)=>{
-    if (!bytes) {
-        return '0';
-    }
-    const i = Math.floor(Math.log(bytes) / Math.log(bytesPerKb));
-    const result = `${parseFloat((bytes / bytesPerKb ** i).toFixed(decimals))} ${sizes[i].padStart(2)}`;
-    return result.padStart(padStart);
-};
-/**
- *
- * Display message(s) to console and then call process.exit with code.
- * If code is zero, console.log and green text is used for messages, otherwise console.error and red text.
- *
- */ const exitWith = (code, message, options = {})=>{
-    const { logger = console, prc = process } = options;
-    const log = (message)=>{
-        if (code === 0) {
-            logger.log(chalk.green(message));
-        } else {
-            logger.error(chalk.red(message));
-        }
-    };
-    if (isString(message)) {
-        log(message);
-    } else if (isArray(message)) {
-        message.forEach((msg)=>log(msg));
-    }
-    prc.exit(code);
-};
-/**
- * assert that a URL object has a protocol value
- *
- */ const assertUrlHasProtocol = (url, protocol)=>{
-    if (!url.protocol) {
-        exitWith(1, `${url.toString()} does not have a protocol`);
-    }
-    // if just checking for the existence of a protocol, return
-    if (!protocol) {
-        return;
-    }
-    if (isString(protocol)) {
-        if (protocol !== url.protocol) {
-            exitWith(1, `${url.toString()} must have the protocol ${protocol}`);
-        }
-        return;
-    }
-    // assume an array
-    if (!protocol.some((protocol)=>url.protocol === protocol)) {
-        return exitWith(1, `${url.toString()} must have one of the following protocols: ${protocol.join(',')}`);
-    }
-};
-/**
- * Passes commander options to conditionCallback(). If it returns true, call isMetCallback otherwise call isNotMetCallback
- */ const ifOptions = (conditionCallback, isMetCallback = async ()=>{}, isNotMetCallback = async ()=>{})=>{
-    return async (command)=>{
-        const opts = command.opts();
-        if (await conditionCallback(opts)) {
-            await isMetCallback(command);
-        } else {
-            await isNotMetCallback(command);
-        }
-    };
-};
-const assertCwdContainsStrapiProject = (name)=>{
-    const logErrorAndExit = ()=>{
-        console.log(`You need to run ${chalk.yellow(`strapi ${name}`)} in a Strapi project. Make sure you are in the right directory.`);
-        process.exit(1);
-    };
-    try {
-        const pkgJSON = require(`${process.cwd()}/package.json`);
-        if (!has('dependencies.@strapi/strapi', pkgJSON) && !has('devDependencies.@strapi/strapi', pkgJSON)) {
-            logErrorAndExit();
-        }
-    } catch (err) {
-        logErrorAndExit();
-    }
-};
-const runAction = (name, action)=>(...args)=>{
-        assertCwdContainsStrapiProject(name);
-        Promise.resolve().then(()=>{
-            return action(...args);
-        }).catch((error)=>{
-            console.error(error);
-            process.exit(1);
-        });
-    };
-
-const emailValidator = yup.string().email('Invalid email address').lowercase();
-const passwordValidator = yup.string().min(8, 'Password must be at least 8 characters long').matches(/[a-z]/, 'Password must contain at least one lowercase character').matches(/[A-Z]/, 'Password must contain at least one uppercase character').matches(/\d/, 'Password must contain at least one number');
-const adminCreateSchema = yup.object().shape({
-    email: emailValidator,
-    password: passwordValidator,
-    firstname: yup.string().trim().required('First name is required'),
-    lastname: yup.string()
-});
-/**
- * It's not an observable, in reality this is
- * `ReadOnlyArray<inquirer.DistinctQuestion<Answers>>`
- * but then the logic of the validate function needs to change.
- */ // eslint-disable-next-line rxjs/finnish
-const promptQuestions$1 = [
-    {
-        type: 'input',
-        name: 'email',
-        message: 'Admin email?',
-        async validate (value) {
-            const validEmail = await emailValidator.validate(value);
-            return validEmail === value || validEmail;
-        }
-    },
-    {
-        type: 'password',
-        name: 'password',
-        message: 'Admin password?',
-        async validate (value) {
-            const validPassword = await passwordValidator.validate(value);
-            return validPassword === value || validPassword;
-        }
-    },
-    {
-        type: 'input',
-        name: 'firstname',
-        message: 'First name?'
-    },
-    {
-        type: 'input',
-        name: 'lastname',
-        message: 'Last name?'
-    },
-    {
-        type: 'confirm',
-        name: 'confirm',
-        message: 'Do you really want to create a new admin?'
-    }
-];
-async function createAdmin({ email, password, firstname, lastname }) {
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    const user = await app.admin.services.user.exists({
-        email
-    });
-    if (user) {
-        console.error(`User with email "${email}" already exists`);
-        process.exit(1);
-    }
-    const superAdminRole = await app.admin.services.role.getSuperAdmin();
-    await app.admin.services.user.create({
-        email,
-        firstname,
-        lastname,
-        isActive: true,
-        roles: [
-            superAdminRole.id
-        ],
-        ...password && {
-            password,
-            registrationToken: null
-        }
-    });
-    console.log(`Successfully created new admin`);
-    process.exit(0);
-}
-/**
- * Create new admin user
- */ const action$m = async (cmdOptions = {})=>{
-    let { email, password, firstname, lastname } = cmdOptions;
-    if (_.isEmpty(email) && _.isEmpty(password) && _.isEmpty(firstname) && _.isEmpty(lastname) && process.stdin.isTTY) {
-        const inquiry = await inquirer.prompt(promptQuestions$1);
-        if (!inquiry.confirm) {
-            process.exit(0);
-        }
-        ({ email, password, firstname, lastname } = inquiry);
-    }
-    try {
-        await adminCreateSchema.validate({
-            email,
-            password,
-            firstname,
-            lastname
-        });
-    } catch (err) {
-        if (err instanceof yup.ValidationError) {
-            console.error(err.errors[0]);
-        }
-        process.exit(1);
-    }
-    return createAdmin({
-        email,
-        password,
-        firstname,
-        lastname
-    });
-};
-/**
- * `$ strapi admin:create-user`
- */ const command$p = ()=>{
-    return createCommand('admin:create-user').alias('admin:create').description('Create a new admin').option('-e, --email <email>', 'Email of the new admin').option('-p, --password <password>', 'Password of the new admin').option('-f, --firstname <first name>', 'First name of the new admin').option('-l, --lastname <last name>', 'Last name of the new admin').action(runAction('admin:create-user', action$m));
-};
-
-const promptQuestions = [
-    {
-        type: 'input',
-        name: 'email',
-        message: 'User email?'
-    },
-    {
-        type: 'password',
-        name: 'password',
-        message: 'New password?'
-    },
-    {
-        type: 'confirm',
-        name: 'confirm',
-        message: "Do you really want to reset this user's password?"
-    }
-];
-async function changePassword({ email, password }) {
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    await app.admin.services.user.resetPasswordByEmail(email, password);
-    console.log(`Successfully reset user's password`);
-    process.exit(0);
-}
-/**
- * Reset user's password
- */ const action$l = async (cmdOptions = {})=>{
-    const { email, password } = cmdOptions;
-    if (_.isEmpty(email) && _.isEmpty(password) && process.stdin.isTTY) {
-        const inquiry = await inquirer.prompt(promptQuestions);
-        if (!inquiry.confirm) {
-            process.exit(0);
-        }
-        return changePassword(inquiry);
-    }
-    if (_.isEmpty(email) || _.isEmpty(password)) {
-        console.error('Missing required options `email` or `password`');
-        process.exit(1);
-    }
-    return changePassword({
-        email,
-        password
-    });
-};
-/**
- * `$ strapi admin:reset-user-password`
- */ const command$o = ()=>{
-    return createCommand('admin:reset-user-password').alias('admin:reset-password').description("Reset an admin user's password").option('-e, --email <email>', 'The user email').option('-p, --password <password>', 'New password for the user').action(runAction('admin:reset-user-password', action$l));
-};
-
-const action$k = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = Object.keys(app.components);
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi components:list`
- */ const command$n = ()=>{
-    return createCommand('components:list').description('List all the application components').action(runAction('components:list', action$k));
-};
-
-const CHUNK_SIZE = 100;
-/**
- * Will dump configurations to a file or stdout
- * @param {string} file filepath to use as output
- */ const action$j = async ({ file: filePath, pretty })=>{
-    const output = filePath ? fs.createWriteStream(filePath) : process.stdout;
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    const count = await app.query('strapi::core-store').count();
-    const exportData = [];
-    const pageCount = Math.ceil(count / CHUNK_SIZE);
-    for(let page = 0; page < pageCount; page += 1){
-        const results = await app.query('strapi::core-store').findMany({
-            limit: CHUNK_SIZE,
-            offset: page * CHUNK_SIZE,
-            orderBy: 'key'
-        });
-        results.filter((result)=>result.key.startsWith('plugin_')).forEach((result)=>{
-            exportData.push({
-                key: result.key,
-                value: result.value,
-                type: result.type,
-                environment: result.environment,
-                tag: result.tag
-            });
-        });
-    }
-    const str = JSON.stringify(exportData, null, pretty ? 2 : undefined);
-    output.write(str);
-    output.write('\n');
-    output.end();
-    // log success only when writting to file
-    if (filePath) {
-        console.log(`Successfully exported ${exportData.length} configuration entries`);
-    }
-    process.exit(0);
-};
-/**
- * `$ strapi configuration:dump`
- */ const command$m = ()=>{
-    return createCommand('configuration:dump').alias('config:dump').description('Dump configurations of your application').option('-f, --file <file>', 'Output file, default output is stdout').option('-p, --pretty', 'Format the output JSON with indentation and line breaks', false).action(runAction('configuration:dump', action$j));
-};
-
-/**
- * Will restore configurations. It reads from a file or stdin
- */ const action$i = async ({ file: filePath, strategy = 'replace' })=>{
-    const input = filePath ? fs.readFileSync(filePath) : await readStdin();
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    let dataToImport;
-    try {
-        dataToImport = JSON.parse(_.toString(input));
-    } catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Invalid input data: ${error.message}. Expected a valid JSON array.`);
-        }
-        throw error;
-    }
-    if (!Array.isArray(dataToImport)) {
-        throw new Error(`Invalid input data. Expected a valid JSON array.`);
-    }
-    if (!app.db) {
-        throw new Error('Cannot import configuration without a database connection.');
-    }
-    const importer = createImporter(app.db, strategy);
-    for (const config of dataToImport){
-        await importer.import(config);
-    }
-    console.log(`Successfully imported configuration with ${strategy} strategy. Statistics: ${importer.printStatistics()}.`);
-    process.exit(0);
-};
-const readStdin = ()=>{
-    const { stdin } = process;
-    let result = '';
-    if (stdin.isTTY) return Promise.resolve(result);
-    return new Promise((resolve, reject)=>{
-        stdin.setEncoding('utf8');
-        stdin.on('readable', ()=>{
-            let chunk;
-            // eslint-disable-next-line no-cond-assign
-            while(chunk = stdin.read()){
-                result += chunk;
-            }
-        });
-        stdin.on('end', ()=>{
-            resolve(result);
-        });
-        stdin.on('error', reject);
-    });
-};
-const createImporter = (db, strategy)=>{
-    switch(strategy){
-        case 'replace':
-            return createReplaceImporter(db);
-        case 'merge':
-            return createMergeImporter(db);
-        case 'keep':
-            return createKeepImporter(db);
-        default:
-            throw new Error(`No importer available for strategy "${strategy}"`);
-    }
-};
-/**
- * Replace importer. Will replace the keys that already exist and create the new ones
- */ const createReplaceImporter = (db)=>{
-    const stats = {
-        created: 0,
-        replaced: 0
-    };
-    return {
-        printStatistics () {
-            return `${stats.created} created, ${stats.replaced} replaced`;
-        },
-        async import (conf) {
-            const matching = await db.query('strapi::core-store').count({
-                where: {
-                    key: conf.key
-                }
-            });
-            if (matching > 0) {
-                stats.replaced += 1;
-                await db.query('strapi::core-store').update({
-                    where: {
-                        key: conf.key
-                    },
-                    data: conf
-                });
-            } else {
-                stats.created += 1;
-                await db.query('strapi::core-store').create({
-                    data: conf
-                });
-            }
-        }
-    };
-};
-/**
- * Merge importer. Will merge the keys that already exist with their new value and create the new ones
- */ const createMergeImporter = (db)=>{
-    const stats = {
-        created: 0,
-        merged: 0
-    };
-    return {
-        printStatistics () {
-            return `${stats.created} created, ${stats.merged} merged`;
-        },
-        async import (conf) {
-            const existingConf = await db.query('strapi::core-store').findOne({
-                where: {
-                    key: conf.key
-                }
-            });
-            if (existingConf) {
-                stats.merged += 1;
-                await db.query('strapi::core-store').update({
-                    where: {
-                        key: conf.key
-                    },
-                    data: _.merge(existingConf, conf)
-                });
-            } else {
-                stats.created += 1;
-                await db.query('strapi::core-store').create({
-                    data: conf
-                });
-            }
-        }
-    };
-};
-/**
- * Merge importer. Will keep the keys that already exist without changing them and create the new ones
- */ const createKeepImporter = (db)=>{
-    const stats = {
-        created: 0,
-        untouched: 0
-    };
-    return {
-        printStatistics () {
-            return `${stats.created} created, ${stats.untouched} untouched`;
-        },
-        async import (conf) {
-            const matching = await db.query('strapi::core-store').count({
-                where: {
-                    key: conf.key
-                }
-            });
-            if (matching > 0) {
-                stats.untouched += 1;
-                // if configuration already exists do not overwrite it
-                return;
-            }
-            stats.created += 1;
-            await db.query('strapi::core-store').create({
-                data: conf
-            });
-        }
-    };
-};
-/**
- * `$ strapi configuration:restore`
- */ const command$l = ()=>{
-    return createCommand('configuration:restore').alias('config:restore').description('Restore configurations of your application').option('-f, --file <file>', 'Input file, default input is stdin').option('-s, --strategy <strategy>', 'Strategy name, one of: "replace", "merge", "keep"').action(runAction('configuration:restore', action$i));
-};
-
-const action$h = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('content-types').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi content-types:list`
- */ const command$k = ()=>{
-    return createCommand('content-types:list').description('List all the application content-types').action(runAction('content-types:list', action$h));
-};
-
-const action$g = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('controllers').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi controllers:list`
- */ const command$j = ()=>{
-    return createCommand('controllers:list').description('List all the application controllers').action(runAction('controllers:list', action$g));
-};
-
-const action$f = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('hooks').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi hooks:list`
- */ const command$i = ()=>{
-    return createCommand('hooks:list').description('List all the application hooks').action(runAction('hooks:list', action$f));
-};
-
-const action$e = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('middlewares').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi middlewares:list`
- */ const command$h = ()=>{
-    return createCommand('middlewares:list').description('List all the application middlewares').action(runAction('middlewares:list', action$e));
-};
-
-const action$d = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('policies').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi policies:list`
- */ const command$g = ()=>{
-    return createCommand('policies:list').description('List all the application policies').action(runAction('policies:list', action$d));
-};
-
-const action$c = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    const list = app.server.mount().listRoutes();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Method'),
-            chalk.blue('Path')
-        ],
-        colWidths: [
-            20
-        ]
-    });
-    list.filter((route)=>route.methods.length).forEach((route)=>{
-        infoTable.push([
-            route.methods.map(toUpper).join('|'),
-            route.path
-        ]);
-    });
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi routes:list``
- */ const command$f = ()=>{
-    return createCommand('routes:list').description('List all the application routes').action(runAction('routes:list', action$c));
-};
-
-const action$b = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    const list = app.get('services').keys();
-    const infoTable = new CLITable({
-        head: [
-            chalk.blue('Name')
-        ]
-    });
-    list.forEach((name)=>infoTable.push([
-            name
-        ]));
-    console.log(infoTable.toString());
-    await app.destroy();
-};
-/**
- * `$ strapi services:list`
- */ const command$e = ()=>{
-    return createCommand('services:list').description('List all the application services').action(runAction('services:list', action$b));
-};
-
-const sendEvent = async (event, uuid)=>{
-    try {
-        await fetch('https://analytics.strapi.io/api/v2/track', {
-            method: 'POST',
-            body: JSON.stringify({
-                event,
-                deviceId: machineID(),
-                groupProperties: {
-                    projectId: uuid
-                }
-            }),
-            headers: {
-                'Content-Type': 'application/json',
-                'X-Strapi-Event': event
-            }
-        });
-    } catch (e) {
-    // ...
-    }
-};
-
-const readPackageJSON$1 = async (path)=>{
-    try {
-        const packageObj = await fse.readJson(path);
-        const uuid = packageObj.strapi ? packageObj.strapi.uuid : null;
-        return {
-            uuid,
-            packageObj
-        };
-    } catch (err) {
-        if (err instanceof Error) {
-            console.error(`${chalk.red('Error')}: ${err.message}`);
-        }
-    }
-};
-const writePackageJSON$1 = async (path, file, spacing)=>{
-    try {
-        await fse.writeJson(path, file, {
-            spaces: spacing
-        });
-        return true;
-    } catch (err) {
-        if (err instanceof Error) {
-            console.error(`${chalk.red('Error')}: ${err.message}`);
-        }
-    }
-};
-const action$a = async ()=>{
-    const packageJSONPath = resolve(process.cwd(), 'package.json');
-    const exists = await fse.pathExists(packageJSONPath);
-    if (!exists) {
-        console.log(`${chalk.yellow('Warning')}: could not find package.json`);
-        process.exit(0);
-    }
-    const { uuid, packageObj } = await readPackageJSON$1(packageJSONPath) ?? {};
-    if (packageObj.strapi && packageObj.strapi.telemetryDisabled || !uuid) {
-        console.log(`${chalk.yellow('Warning:')} telemetry is already disabled`);
-        process.exit(0);
-    }
-    const updatedPackageJSON = {
-        ...packageObj,
-        strapi: {
-            ...packageObj.strapi,
-            telemetryDisabled: true
-        }
-    };
-    const write = await writePackageJSON$1(packageJSONPath, updatedPackageJSON, 2);
-    if (!write) {
-        console.log(`${chalk.yellow('Warning')}: There has been an error, please set "telemetryDisabled": true in the "strapi" object of your package.json manually.`);
-        process.exit(0);
-    }
-    await sendEvent('didOptOutTelemetry', uuid);
-    console.log(`${chalk.green('Successfully opted out of Strapi telemetry')}`);
-    process.exit(0);
-};
-/**
- * `$ strapi telemetry:disable`
- */ const command$d = ()=>{
-    return createCommand('telemetry:disable').description('Disable anonymous telemetry and metadata sending to Strapi analytics').action(runAction('telemetry:disable', action$a));
-};
-
-const readPackageJSON = async (path)=>{
-    try {
-        const packageObj = await fse.readJson(path);
-        return packageObj;
-    } catch (err) {
-        if (err instanceof Error) {
-            console.error(`${chalk.red('Error')}: ${err.message}`);
-        } else {
-            throw err;
-        }
-    }
-};
-const writePackageJSON = async (path, file, spacing)=>{
-    try {
-        await fse.writeJson(path, file, {
-            spaces: spacing
-        });
-        return true;
-    } catch (err) {
-        if (err instanceof Error) {
-            console.error(`${chalk.red('Error')}: ${err.message}`);
-            console.log(`${chalk.yellow('Warning')}: There has been an error, please set "telemetryDisabled": false in the "strapi" object of your package.json manually.`);
-            return false;
-        }
-        throw err;
-    }
-};
-const generateNewPackageJSON = (packageObj)=>{
-    if (!packageObj.strapi) {
-        return {
-            ...packageObj,
-            strapi: {
-                uuid: randomUUID(),
-                telemetryDisabled: false
-            }
-        };
-    }
-    return {
-        ...packageObj,
-        strapi: {
-            ...packageObj.strapi,
-            uuid: packageObj.strapi.uuid ? packageObj.strapi.uuid : randomUUID(),
-            telemetryDisabled: false
-        }
-    };
-};
-const action$9 = async ()=>{
-    const packageJSONPath = resolve(process.cwd(), 'package.json');
-    const exists = await fse.pathExists(packageJSONPath);
-    if (!exists) {
-        console.log(`${chalk.yellow('Warning')}: could not find package.json`);
-        process.exit(0);
-    }
-    const packageObj = await readPackageJSON(packageJSONPath);
-    if (packageObj.strapi && packageObj.strapi.uuid) {
-        if (packageObj.strapi.telemetryDisabled === false) {
-            console.log(`${chalk.yellow('Warning:')} telemetry is already enabled`);
-            process.exit(0);
-        }
-    }
-    const updatedPackageJSON = generateNewPackageJSON(packageObj);
-    const write = await writePackageJSON(packageJSONPath, updatedPackageJSON, 2);
-    if (!write) {
-        process.exit(0);
-    }
-    await sendEvent('didOptInTelemetry', updatedPackageJSON.strapi.uuid);
-    console.log(`${chalk.green('Successfully opted into and enabled Strapi telemetry')}`);
-    process.exit(0);
-};
-/**
- * `$ strapi telemetry:enable`
- */ const command$c = ()=>{
-    return createCommand('telemetry:enable').description('Enable anonymous telemetry and metadata sending to Strapi analytics').action(runAction('telemetry:enable', action$9));
-};
-
-/**
- *`$ strapi templates:generate <directory>`
- */ const command$b = ()=>{
-    return createCommand('templates:generate <directory>').description('(deprecated) Generate template from Strapi project').action(()=>{
-        console.warn('This command is deprecated and will be removed in the next major release.');
-        console.warn('You can now copy an existing app and use it as a template.');
-    });
-};
-
-const action$8 = async ({ debug, silent, verbose, outDir })=>{
-    if ((debug || verbose) && silent) {
-        console.error('Flags conflict: both silent and debug mode are enabled, exiting...');
-        process.exit(1);
-    }
-    const appContext = await compileStrapi({
-        ignoreDiagnostics: true
-    });
-    const app = await createStrapi(appContext).register();
-    await tsUtils__default.generators.generate({
-        strapi: app,
-        pwd: appContext.appDir,
-        rootDir: outDir ?? undefined,
-        logger: {
-            silent,
-            debug
-        },
-        artifacts: {
-            contentTypes: true,
-            components: true
-        }
-    });
-    await app.destroy();
-};
-/**
- * `$ strapi ts:generate-types`
- */ const command$a = ()=>{
-    return createCommand('ts:generate-types').description(`Generate TypeScript typings for your schemas`).option('-d, --debug', `Run the generation with debug messages`, false).option('-s, --silent', `Run the generation silently, without any output`, false).option('-o, --out-dir <outDir>', 'Specify a relative root directory in which the definitions will be generated. Changing this value might break types exposed by Strapi that relies on generated types.').action(runAction('ts:generate-types', action$8));
-};
-
-/**
- * @description Supports the following managers:
- * – npm
- * – yarn
- * – pnpm
- */ const getPackageManager = ()=>{
-    // Yes, the env var is lowercase - it is set by the package managers themselves
-    const agent = process.env.npm_config_user_agent || '';
-    if (agent.includes('yarn')) {
-        return 'yarn';
-    }
-    if (agent.includes('pnpm')) {
-        return 'pnpm';
-    }
-    // Both yarn and pnpm does a `npm/?` thing, thus the slightly different match here
-    // Theoretically not needed since we check for yarn/pnpm above, but in case other
-    // package managers do the same thing, we'll (hopefully) catch them here.
-    if (/^npm\/\d/.test(agent)) {
-        return 'npm';
-    }
-    return undefined;
-};
-
-/**
- * From V5 this will be imported from the package.json of `@strapi/strapi`.
- */ const PEER_DEPS = {
-    react: '^18.0.0',
-    'react-dom': '^18.0.0',
-    'react-router-dom': '^6.0.0',
-    'styled-components': '^6.0.0'
-};
-/**
- * Checks the user's project that it has declared and installed the required dependencies
- * needed by the Strapi admin project. Whilst generally speaking most modules will be
- * declared by the actual packages there are some packages where you only really want one of
- * and thus they are declared as peer dependencies – react / styled-components / etc.
- *
- * If these deps are not installed or declared, then we prompt the user to correct this. In
- * V4 this is not a hard requirement, but in V5 it will be. Might as well get people started now.
- */ const checkRequiredDependencies = async ({ cwd, logger })=>{
-    /**
-   * This enables us to use experimental deps for libraries like
-   * react or styled-components. This is useful for testing against.
-   */ if (process.env.USE_EXPERIMENTAL_DEPENDENCIES === 'true') {
-        logger.warn('You are using experimental dependencies that may not be compatible with Strapi.');
-        return {
-            didInstall: false
-        };
-    }
-    const pkg = await readPkgUp({
-        cwd
-    });
-    if (!pkg) {
-        throw new Error(`Could not find package.json at path: ${cwd}`);
-    }
-    logger.debug('Loaded package.json:', os.EOL, pkg.packageJson);
-    /**
-   * Run through each of the peer deps and figure out if they need to be
-   * installed or they need their version checked against.
-   */ const { install, review } = Object.entries(PEER_DEPS).reduce((acc, [name, version])=>{
-        if (!pkg.packageJson.dependencies) {
-            throw new Error(`Could not find dependencies in package.json at path: ${cwd}`);
-        }
-        const declaredVersion = pkg.packageJson.dependencies[name];
-        if (!declaredVersion) {
-            acc.install.push({
-                name,
-                wantedVersion: version
-            });
-        } else {
-            acc.review.push({
-                name,
-                wantedVersion: version,
-                declaredVersion
-            });
-        }
-        return acc;
-    }, {
-        install: [],
-        review: []
-    });
-    if (install.length > 0) {
-        logger.info('The Strapi admin needs to install the following dependencies:', os.EOL, install.map(({ name, wantedVersion })=>`  - ${name}@${wantedVersion}`).join(os.EOL));
-        await installDependencies(install, {
-            cwd,
-            logger
-        });
-        const [file, ...args] = process.argv;
-        /**
-     * Re-run the same command after installation e.g. strapi build because the yarn.lock might
-     * not be the same and could break installations. It's not the best solution, but it works.
-     */ await execa(file, args, {
-            cwd,
-            stdio: 'inherit'
-        });
-        return {
-            didInstall: true
-        };
-    }
-    if (review.length) {
-        const errors = [];
-        for (const dep of review){
-            // The version specified in package.json could be incorrect, eg `foo`
-            let minDeclaredVersion = null;
-            try {
-                minDeclaredVersion = semver.minVersion(dep.declaredVersion);
-            } catch (err) {
-            // Intentional fall-through (variable will be left as null, throwing below)
-            }
-            if (!minDeclaredVersion) {
-                errors.push(`The declared dependency, ${dep.name} has an invalid version in package.json: ${dep.declaredVersion}`);
-            } else if (!semver.satisfies(minDeclaredVersion, dep.wantedVersion)) {
-                /**
-         * The delcared version should be semver compatible with our required version
-         * of the dependency. If it's not, we should advise the user to change it.
-         */ logger.warn([
-                    `Declared version of ${dep.name} (${minDeclaredVersion}) is not compatible with the version required by Strapi (${dep.wantedVersion}).`,
-                    'You may experience issues, we recommend you change this.'
-                ].join(os.EOL));
-            }
-            const installedVersion = await getModuleVersion(dep.name, cwd);
-            if (!installedVersion) {
-                /**
-         * TODO: when we know the packageManager we can advise the actual install command.
-         */ errors.push(`The declared dependency, ${dep.name} is not installed. You should install before re-running this command`);
-            } else if (!semver.satisfies(installedVersion, dep.wantedVersion)) {
-                logger.warn([
-                    `Declared version of ${dep.name} (${installedVersion}) is not compatible with the version required by Strapi (${dep.wantedVersion}).`,
-                    'You may experience issues, we recommend you change this.'
-                ].join(os.EOL));
-            }
-        }
-        if (errors.length > 0 && process.env.NODE_ENV === 'development') {
-            throw new Error(`${os.EOL}- ${errors.join(`${os.EOL}- `)}`);
-        }
-    }
-    return {
-        didInstall: false
-    };
-};
-const getModule = async (name, cwd)=>{
-    const modulePackagePath = resolveFrom.silent(cwd, path.join(name, 'package.json'));
-    if (!modulePackagePath) {
-        return null;
-    }
-    const file = await fs$1.readFile(modulePackagePath, 'utf8').then((res)=>JSON.parse(res));
-    return file;
-};
-const getModuleVersion = async (name, cwd)=>{
-    const pkg = await getModule(name, cwd);
-    return pkg?.version || null;
-};
-const installDependencies = async (install, { cwd, logger })=>{
-    const packageManager = getPackageManager();
-    if (!packageManager) {
-        logger.error('Could not find a supported package manager, please install the dependencies manually.');
-        process.exit(1);
-    }
-    const execOptions = {
-        encoding: 'utf8',
-        cwd,
-        stdio: 'inherit'
-    };
-    const packages = install.map(({ name, wantedVersion })=>`${name}@${wantedVersion}`);
-    let result;
-    if (packageManager === 'npm') {
-        const npmArgs = [
-            'install',
-            '--legacy-peer-deps',
-            '--save',
-            ...packages
-        ];
-        logger.info(`Running 'npm ${npmArgs.join(' ')}'`);
-        result = await execa('npm', npmArgs, execOptions);
-    } else if (packageManager === 'yarn') {
-        const yarnArgs = [
-            'add',
-            ...packages
-        ];
-        logger.info(`Running 'yarn ${yarnArgs.join(' ')}'`);
-        result = await execa('yarn', yarnArgs, execOptions);
-    } else if (packageManager === 'pnpm') {
-        const pnpmArgs = [
-            'add',
-            '--save-prod',
-            ...packages
-        ];
-        logger.info(`Running 'pnpm ${pnpmArgs.join(' ')}'`);
-        result = await execa('pnpm', pnpmArgs, execOptions);
-    }
-    if (result?.exitCode || result?.failed) {
-        throw new Error('Package installation failed');
-    }
-};
-
-function getTimer() {
-    const timings = {};
-    const startTimes = {};
-    function start(name) {
-        if (typeof startTimes[name] !== 'undefined') {
-            throw new Error(`Timer "${name}" already started, cannot overwrite`);
-        }
-        startTimes[name] = performance.now();
-    }
-    function end(name) {
-        if (typeof startTimes[name] === 'undefined') {
-            throw new Error(`Timer "${name}" never started, cannot end`);
-        }
-        timings[name] = performance.now() - startTimes[name];
-        return timings[name];
-    }
-    return {
-        start,
-        end,
-        getTimings: ()=>timings
-    };
-}
-const prettyTime = (timeInMs)=>{
-    return `${Math.ceil(timeInMs)}ms`;
-};
-
-/**
- * @internal
- */ const pathExists = async (path)=>{
-    try {
-        await access(path);
-        return true;
-    } catch (error) {
-        return false;
-    }
-};
-/**
- * @internal
- */ const loadFile = async (path)=>{
-    if (await pathExists(path)) {
-        const esbuildOptions = {
-            extensions: [
-                '.js',
-                '.mjs',
-                '.ts'
-            ]
-        };
-        const { unregister } = register(esbuildOptions);
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const mod = require(path);
-        unregister();
-        /**
-     * handles esm or cjs exporting.
-     */ const file = mod?.default || mod || undefined;
-        return file;
-    }
-    return undefined;
-};
-/**
- * @internal
- *
- * @description Converts a system path to a module path mainly for `Windows` systems.
- * where the path separator is `\` instead of `/`, on linux systems the path separator
- * is identical to the module path separator.
- */ const convertSystemPathToModulePath = (sysPath)=>{
-    if (process.platform === 'win32') {
-        return sysPath.split(path.sep).join(path.posix.sep);
-    }
-    return sysPath;
-};
-/**
- * @internal
- *
- * @description Converts a module path to a system path, again largely used for Windows systems.
- * The original use case was plugins where the resolve path was in module format but we want to
- * have it relative to the runtime directory.
- */ const convertModulePathToSystemPath = (modulePath)=>{
-    if (process.platform === 'win32') {
-        return modulePath.split(path.posix.sep).join(path.sep);
-    }
-    return modulePath;
-};
-
-/**
- * @internal
- *
- * @description Load the .env file if it exists
- */ const loadEnv = async (cwd)=>{
-    const pathToEnv = path.resolve(cwd, '.env');
-    if (await pathExists(pathToEnv)) {
-        dotenv.config({
-            path: pathToEnv
-        });
-    }
-};
-/**
- * @internal
- *
- * @description Get all the environment variables that start with `STRAPI_ADMIN_`
- */ const getStrapiAdminEnvVars = (defaultEnv)=>{
-    return Object.keys(process.env).filter((key)=>key.toUpperCase().startsWith('STRAPI_ADMIN_')).reduce((acc, key)=>{
-        acc[key] = process.env[key];
-        return acc;
-    }, defaultEnv);
-};
-
-const isError = (err)=>err instanceof Error;
-/**
- * @description Handle unexpected errors. No, but really, your CLI should anticipate error cases.
- * If a user hits an error we don't expect, then we need to flag to them that this is not normal
- * and they should use the `--debug` flag to get more information (assuming you've implemented this
- * in your action).
- */ const handleUnexpectedError = (err)=>{
-    console.error(chalk.red(`[ERROR] `, 'There seems to be an unexpected error, try again with --debug for more information', os.EOL));
-    if (isError(err) && err.stack) {
-        // eslint-disable-next-line no-console
-        console.log(chalk.red(boxen(err.stack, {
-            padding: 1,
-            align: 'left'
-        })));
-    }
-    if (err instanceof errors.YupValidationError) {
-        const message = [];
-        const size = err.details.errors.length;
-        for (const error of err.details.errors){
-            // No need to repeat the error message as it's the same as the err.message
-            if (size === 1) {
-                message.push(`  value: ${error.value}`);
-                continue;
-            }
-            message.push([
-                `  [${error.name}]`,
-                `    message: ${error.message}`,
-                `      value: ${error.value}`
-            ].join('\n'));
-        }
-        console.log(chalk.red(boxen([
-            'Details:',
-            message.join('\n\n')
-        ].join('\n'), {
-            padding: 1,
-            align: 'left'
-        })));
-    }
-    process.exit(1);
-};
-
-const validatePackageHasStrapi = (pkg)=>'strapi' in pkg && typeof pkg.strapi === 'object' && !Array.isArray(pkg.strapi) && pkg.strapi !== null;
-const validatePackageIsPlugin = (pkg)=>validatePackageHasStrapi(pkg) && pkg.strapi.kind === 'plugin';
-const getEnabledPlugins = async ({ cwd, logger, runtimeDir, strapi })=>{
-    const plugins = {};
-    /**
-   * This is the list of dependencies that are installed in the user's project.
-   * It will include libraries like "react", so we need to collect the ones that
-   * are plugins.
-   */ const deps = strapi.config.get('info.dependencies', {});
-    logger.debug("Dependencies from user's project", os.EOL, deps);
-    for (const dep of Object.keys(deps)){
-        const pkg = await getModule(dep, cwd);
-        if (pkg && validatePackageIsPlugin(pkg)) {
-            const name = pkg.strapi.name || pkg.name;
-            if (!name) {
-                /**
-         * Unlikely to happen, but you never know.
-         */ throw Error("You're trying to import a plugin that doesn't have a name – check the package.json of that plugin!");
-            }
-            plugins[name] = {
-                name,
-                importName: camelCase(name),
-                type: 'module',
-                modulePath: dep
-            };
-        }
-    }
-    const userPluginsFile = await loadUserPluginsFile(strapi.dirs.app.config);
-    logger.debug("User's plugins file", os.EOL, userPluginsFile);
-    for (const [userPluginName, userPluginConfig] of Object.entries(userPluginsFile)){
-        if (userPluginConfig.enabled && userPluginConfig.resolve) {
-            const sysPath = convertModulePathToSystemPath(userPluginConfig.resolve);
-            plugins[userPluginName] = {
-                name: userPluginName,
-                importName: camelCase(userPluginName),
-                type: 'local',
-                /**
-         * User plugin paths are resolved from the entry point
-         * of the app, because that's how you import them.
-         */ modulePath: convertSystemPathToModulePath(path.relative(runtimeDir, sysPath)),
-                path: sysPath
-            };
-        }
-    }
-    return plugins;
-};
-const PLUGIN_CONFIGS = [
-    'plugins.js',
-    'plugins.mjs',
-    'plugins.ts'
-];
-const loadUserPluginsFile = async (root)=>{
-    for (const file of PLUGIN_CONFIGS){
-        const filePath = path.join(root, file);
-        const configFile = await loadFile(filePath);
-        if (configFile) {
-            /**
-       * Configs can be a function or they can be just an object!
-       */ return typeof configFile === 'function' ? configFile({
-                env
-            }) : configFile;
-        }
-    }
-    return {};
-};
-const getMapOfPluginsWithAdmin = (plugins)=>{
-    /**
-   * This variable stores the import paths for plugins.
-   * The keys are the module paths of the plugins, and the values are the paths
-   * to the admin part of the plugins, which is either loaded from the
-   * package.json exports or from the legacy strapi-admin.js file.
-   */ const pluginImportPaths = {};
-    return Object.values(plugins).filter((plugin)=>{
-        if (!plugin) {
-            return false;
-        }
-        /**
-       * There are two ways a plugin should be imported, either it's local to the strapi app,
-       * or it's an actual npm module that's installed and resolved via node_modules.
-       *
-       * We first check if the plugin is local to the strapi app, using a regular `fs.existsSync` because
-       * the pathToPlugin will be relative i.e. `/Users/my-name/strapi-app/src/plugins/my-plugin`.
-       *
-       * If the file doesn't exist well then it's probably a node_module, so instead we use `require.resolve`
-       * which will resolve the path to the module in node_modules. If it fails with the specific code `MODULE_NOT_FOUND`
-       * then it doesn't have an admin part to the package.
-       */ try {
-            const localPluginPath = plugin.path;
-            if (localPluginPath) {
-                // Here we are loading a locally installed plugin
-                const packageJsonPath = path.join(localPluginPath, 'package.json');
-                if (fs$2.existsSync(packageJsonPath)) {
-                    const packageJson = JSON.parse(fs$2.readFileSync(packageJsonPath, 'utf-8'));
-                    const localAdminPath = packageJson?.exports?.['./strapi-admin']?.import;
-                    if (localAdminPath) {
-                        pluginImportPaths[plugin.modulePath] = localAdminPath;
-                        return true;
-                    }
-                }
-                // Check if legacy admin file exists in local plugin
-                if (fs$2.existsSync(path.join(localPluginPath, 'strapi-admin.js'))) {
-                    pluginImportPaths[plugin.modulePath] = 'strapi-admin';
-                    return true;
-                }
-            }
-            // This plugin is a module, so we need to check if it has a strapi-admin export
-            if (require.resolve(`${plugin.modulePath}/strapi-admin`)) {
-                pluginImportPaths[plugin.modulePath] = 'strapi-admin';
-                return true;
-            }
-            return false;
-        } catch (err) {
-            if (isError(err) && 'code' in err && (err.code === 'MODULE_NOT_FOUND' || err.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED')) {
-                /**
-           * the plugin does not contain FE code, so we
-           * don't want to import it anyway
-           */ return false;
-            }
-            throw err;
-        }
-    }).map((plugin)=>({
-            ...plugin,
-            modulePath: `${plugin.modulePath}/${pluginImportPaths[plugin.modulePath]}`
-        }));
-};
-
-const ADMIN_APP_FILES = [
-    'app.js',
-    'app.mjs',
-    'app.ts',
-    'app.jsx',
-    'app.tsx'
-];
-const loadUserAppFile = async ({ runtimeDir, appDir })=>{
-    for (const file of ADMIN_APP_FILES){
-        const filePath = path.join(appDir, 'src', 'admin', file);
-        if (await pathExists(filePath)) {
-            return {
-                path: filePath,
-                modulePath: convertSystemPathToModulePath(path.relative(runtimeDir, filePath))
-            };
-        }
-    }
-    return undefined;
-};
-
-const DEFAULT_BROWSERSLIST = [
-    'last 3 major versions',
-    'Firefox ESR',
-    'last 2 Opera versions',
-    'not dead'
-];
-const createBuildContext = async ({ cwd, logger, tsconfig, strapi, options = {} })=>{
-    /**
-   * If you make a new strapi instance when one already exists,
-   * you will overwrite the global and the app will _most likely_
-   * crash and die.
-   */ const strapiInstance = strapi ?? createStrapi({
-        // Directories
-        appDir: cwd,
-        distDir: tsconfig?.config.options.outDir ?? '',
-        // Options
-        autoReload: true,
-        serveAdminPanel: false
-    });
-    const serverAbsoluteUrl = strapiInstance.config.get('server.absoluteUrl');
-    const adminAbsoluteUrl = strapiInstance.config.get('admin.absoluteUrl');
-    const adminPath = strapiInstance.config.get('admin.path');
-    // NOTE: Checks that both the server and admin will be served from the same origin (protocol, host, port)
-    const sameOrigin = new URL(adminAbsoluteUrl).origin === new URL(serverAbsoluteUrl).origin;
-    const adminPublicPath = new URL(adminAbsoluteUrl).pathname;
-    const serverPublicPath = new URL(serverAbsoluteUrl).pathname;
-    const appDir = strapiInstance.dirs.app.root;
-    await loadEnv(cwd);
-    const env = getStrapiAdminEnvVars({
-        ADMIN_PATH: adminPublicPath,
-        STRAPI_ADMIN_BACKEND_URL: sameOrigin ? serverPublicPath : serverAbsoluteUrl,
-        STRAPI_TELEMETRY_DISABLED: String(strapiInstance.telemetry.isDisabled)
-    });
-    const envKeys = Object.keys(env);
-    if (envKeys.length > 0) {
-        logger.info([
-            'Including the following ENV variables as part of the JS bundle:',
-            ...envKeys.map((key)=>`    - ${key}`)
-        ].join(os.EOL));
-    }
-    const distPath = path.join(strapiInstance.dirs.dist.root, 'build');
-    const distDir = path.relative(cwd, distPath);
-    /**
-   * If the distPath already exists, clean it
-   */ try {
-        logger.debug(`Cleaning dist folder: ${distPath}`);
-        await fs$1.rm(distPath, {
-            recursive: true,
-            force: true
-        });
-        logger.debug('Cleaned dist folder');
-    } catch  {
-        // do nothing, it will fail if the folder does not exist
-        logger.debug('There was no dist folder to clean');
-    }
-    const runtimeDir = path.join(cwd, '.strapi', 'client');
-    const entry = path.relative(cwd, path.join(runtimeDir, 'app.js'));
-    const plugins = await getEnabledPlugins({
-        cwd,
-        logger,
-        runtimeDir,
-        strapi: strapiInstance
-    });
-    logger.debug('Enabled plugins', os.EOL, plugins);
-    const pluginsWithFront = getMapOfPluginsWithAdmin(plugins);
-    logger.debug('Enabled plugins with FE', os.EOL, pluginsWithFront);
-    const target = browserslist.loadConfig({
-        path: cwd
-    }) ?? DEFAULT_BROWSERSLIST;
-    const customisations = await loadUserAppFile({
-        appDir,
-        runtimeDir
-    });
-    const features = strapiInstance.config.get('features', undefined);
-    const { bundler = 'vite', ...restOptions } = options;
-    const buildContext = {
-        appDir,
-        adminPath,
-        basePath: adminPublicPath,
-        bundler,
-        customisations,
-        cwd,
-        distDir,
-        distPath,
-        entry,
-        env,
-        features,
-        logger,
-        options: restOptions,
-        plugins: pluginsWithFront,
-        runtimeDir,
-        strapi: strapiInstance,
-        target,
-        tsconfig
-    };
-    return buildContext;
-};
-
-const getEntryModule = (ctx)=>{
-    const pluginsObject = ctx.plugins.map(({ name, importName })=>`'${name}': ${importName}`).join(',\n');
-    const pluginsImport = ctx.plugins.map(({ importName, modulePath })=>`import ${importName} from '${modulePath}';`).join('\n');
-    return outdent`
-        /**
-         * This file was automatically generated by Strapi.
-         * Any modifications made will be discarded.
-         */
-        ${pluginsImport}
-        import { renderAdmin } from "@strapi/strapi/admin"
-
-        ${ctx.customisations?.modulePath ? `import customisations from '${ctx.customisations.modulePath}'` : ''}
-
-        renderAdmin(
-          document.getElementById("strapi"),
-          {
-            ${ctx.customisations?.modulePath ? 'customisations,' : ''}
-            ${ctx.features ? `features: ${JSON.stringify(ctx.features)},` : ''}
-            plugins: {
-        ${pluginsObject}
-            }
-        })
-      `;
-};
-/**
- * TODO: Here in the future we could add the ability
- * to load a user's Document component?
- */ const getDocumentHTML = ({ logger, props = {} })=>{
-    const result = renderToStaticMarkup(createElement(DefaultDocument, props));
-    logger.debug('Rendered the HTML');
-    return outdent`<!DOCTYPE html>${result}`;
-};
-const AUTO_GENERATED_WARNING = `
-This file was automatically generated by Strapi.
-Any modifications made will be discarded.
-`.trim();
-/**
- * Because we now auto-generate the index.html file,
- * we should be clear that people _should not_ modify it.
- *
- * @internal
- */ const decorateHTMLWithAutoGeneratedWarning = (htmlTemplate)=>htmlTemplate.replace(/<head/, `\n<!--\n${AUTO_GENERATED_WARNING}\n-->\n<head`);
-const writeStaticClientFiles = async (ctx)=>{
-    const prettier = await import('prettier'); // ESM-only
-    /**
-   * For everything to work effectively we create a client folder in `.strapi` at the cwd level.
-   * We then use the function we need to "createAdmin" as well as generate the Document index.html as well.
-   *
-   * All this links together an imaginary "src/index" that then allows vite to correctly build the admin panel.
-   */ await fs$1.mkdir(ctx.runtimeDir, {
-        recursive: true
-    });
-    ctx.logger.debug('Created the runtime directory');
-    const indexHtml = decorateHTMLWithAutoGeneratedWarning(await getDocumentHTML({
-        logger: ctx.logger,
-        props: ctx.bundler === 'vite' ? {
-            entryPath: `/${ctx.entry}`
-        } : undefined
-    }));
-    await fs$1.writeFile(path.join(ctx.runtimeDir, 'index.html'), await prettier.format(indexHtml, {
-        parser: 'html'
-    }));
-    ctx.logger.debug('Wrote the index.html file');
-    await fs$1.writeFile(path.join(ctx.runtimeDir, 'app.js'), await prettier.format(getEntryModule(ctx), {
-        parser: 'babel'
-    }));
-    ctx.logger.debug('Wrote the app.js file');
-};
-
-/**
- * @example `$ strapi build`
- *
- * @description Builds the admin panel of the strapi application.
- */ const build = async ({ logger, cwd, tsconfig, ...options })=>{
-    const timer = getTimer();
-    const { didInstall } = await checkRequiredDependencies({
-        cwd,
-        logger
-    }).catch((err)=>{
-        logger.error(err.message);
-        process.exit(1);
-    });
-    if (didInstall) {
-        return;
-    }
-    if (tsconfig?.config) {
-        timer.start('compilingTS');
-        const compilingTsSpinner = logger.spinner(`Compiling TS`).start();
-        tsUtils.compile(cwd, {
-            configOptions: {
-                ignoreDiagnostics: false
-            }
-        });
-        const compilingDuration = timer.end('compilingTS');
-        compilingTsSpinner.text = `Compiling TS (${prettyTime(compilingDuration)})`;
-        compilingTsSpinner.succeed();
-    }
-    timer.start('createBuildContext');
-    const contextSpinner = logger.spinner(`Building build context`).start();
-    console.log('');
-    const ctx = await createBuildContext({
-        cwd,
-        logger,
-        tsconfig,
-        options
-    });
-    const contextDuration = timer.end('createBuildContext');
-    contextSpinner.text = `Building build context (${prettyTime(contextDuration)})`;
-    contextSpinner.succeed();
-    timer.start('buildAdmin');
-    const buildingSpinner = logger.spinner(`Building admin panel`).start();
-    console.log('');
-    try {
-        await writeStaticClientFiles(ctx);
-        if (ctx.bundler === 'webpack') {
-            const { build: buildWebpack } = await import('./build-FJLfahVt.mjs');
-            await buildWebpack(ctx);
-        } else if (ctx.bundler === 'vite') {
-            const { build: buildVite } = await import('./build-BQMdiYL1.mjs');
-            await buildVite(ctx);
-        }
-        const buildDuration = timer.end('buildAdmin');
-        buildingSpinner.text = `Building admin panel (${prettyTime(buildDuration)})`;
-        buildingSpinner.succeed();
-    } catch (err) {
-        buildingSpinner.fail();
-        throw err;
-    }
-};
-
-const action$7 = async (options)=>{
-    try {
-        if (options.bundler === 'webpack') {
-            options.logger.warn('[@strapi/strapi]: Using webpack as a bundler is deprecated. You should migrate to vite.');
-        }
-        await build(options);
-    } catch (err) {
-        handleUnexpectedError(err);
-    }
-};
-/**
- * `$ strapi build`
- */ const command$9 = ({ ctx })=>{
-    return createCommand('build').option('--bundler [bundler]', 'Bundler to use (webpack or vite)', 'vite').option('-d, --debug', 'Enable debugging mode with verbose logs', false).option('--minify', 'Minify the output', true).option('--silent', "Don't log anything", false).option('--sourcemap', 'Produce sourcemaps', false).option('--stats', 'Print build statistics to the console', false).description('Build the strapi admin app').action(async (options)=>{
-        return action$7({
-            ...options,
-            ...ctx
-        });
-    });
-};
-
-const action$6 = async ()=>{
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).load();
-    app.start().then(()=>{
-        const repl = REPL.start(app.config.info.name + ' > ' || 'strapi > '); // eslint-disable-line prefer-template
-        repl.on('exit', (err)=>{
-            if (err) {
-                app.log.error(err);
-                process.exit(1);
-            }
-            app.server.destroy();
-            process.exit(0);
-        });
-    });
-};
-/**
- * `$ strapi console`
- */ const command$8 = ()=>{
-    return createCommand('console').description('Open the Strapi framework console').action(runAction('console', action$6));
-};
-
-// This method removes all non-admin build files from the dist directory
-const cleanupDistDirectory = async ({ tsconfig, logger, timer })=>{
-    const distDir = tsconfig?.config?.options?.outDir;
-    if (!distDir || // we don't have a dist dir
-    await fs$1.access(distDir).then(()=>false).catch(()=>true) // it doesn't exist -- if it does but no access, that will be caught later
-    ) {
-        return;
-    }
-    const timerName = `cleaningDist${Date.now()}`;
-    timer.start(timerName);
-    const cleaningSpinner = logger.spinner(`Cleaning dist dir ${distDir}`).start();
-    try {
-        const dirContent = await fs$1.readdir(distDir);
-        const validFilenames = dirContent// Ignore the admin build folder
-        .filter((filename)=>filename !== 'build');
-        for (const filename of validFilenames){
-            await fs$1.rm(path.resolve(distDir, filename), {
-                recursive: true
-            });
-        }
-    } catch (err) {
-        const generatingDuration = timer.end(timerName);
-        cleaningSpinner.text = `Error cleaning dist dir: ${err} (${prettyTime(generatingDuration)})`;
-        cleaningSpinner?.fail();
-        return;
-    }
-    const generatingDuration = timer.end(timerName);
-    cleaningSpinner.text = `Cleaning dist dir (${prettyTime(generatingDuration)})`;
-    cleaningSpinner?.succeed();
-};
-const develop = async ({ cwd, polling, logger, tsconfig, watchAdmin, ...options })=>{
-    const timer = getTimer();
-    if (cluster.isPrimary) {
-        const { didInstall } = await checkRequiredDependencies({
-            cwd,
-            logger
-        }).catch((err)=>{
-            logger.error(err.message);
-            process.exit(1);
-        });
-        if (didInstall) {
-            return;
-        }
-        if (tsconfig?.config) {
-            // Build without diagnostics in case schemas have changed
-            await cleanupDistDirectory({
-                tsconfig,
-                logger,
-                timer
-            });
-            await tsUtils.compile(cwd, {
-                configOptions: {
-                    ignoreDiagnostics: true
-                }
-            });
-        }
-        /**
-     * IF we're not watching the admin we're going to build it, this makes
-     * sure that at least the admin is built for users & they can interact
-     * with the application.
-     */ if (!watchAdmin) {
-            timer.start('createBuildContext');
-            const contextSpinner = logger.spinner(`Building build context`).start();
-            console.log('');
-            const ctx = await createBuildContext({
-                cwd,
-                logger,
-                tsconfig,
-                options
-            });
-            const contextDuration = timer.end('createBuildContext');
-            contextSpinner.text = `Building build context (${prettyTime(contextDuration)})`;
-            contextSpinner.succeed();
-            timer.start('creatingAdmin');
-            const adminSpinner = logger.spinner(`Creating admin`).start();
-            await writeStaticClientFiles(ctx);
-            if (ctx.bundler === 'webpack') {
-                const { build: buildWebpack } = await import('./build-FJLfahVt.mjs');
-                await buildWebpack(ctx);
-            } else if (ctx.bundler === 'vite') {
-                const { build: buildVite } = await import('./build-BQMdiYL1.mjs');
-                await buildVite(ctx);
-            }
-            const adminDuration = timer.end('creatingAdmin');
-            adminSpinner.text = `Creating admin (${prettyTime(adminDuration)})`;
-            adminSpinner.succeed();
-        }
-        cluster.on('message', async (worker, message)=>{
-            switch(message){
-                case 'reload':
-                    {
-                        if (tsconfig?.config) {
-                            // Build without diagnostics in case schemas have changed
-                            await cleanupDistDirectory({
-                                tsconfig,
-                                logger,
-                                timer
-                            });
-                            await tsUtils.compile(cwd, {
-                                configOptions: {
-                                    ignoreDiagnostics: true
-                                }
-                            });
-                        }
-                        logger.debug('cluster has the reload message, sending the worker kill message');
-                        worker.send('kill');
-                        break;
-                    }
-                case 'killed':
-                    {
-                        logger.debug('cluster has the killed message, forking the cluster');
-                        cluster.fork();
-                        break;
-                    }
-                case 'stop':
-                    {
-                        process.exit(1);
-                        break;
-                    }
-            }
-        });
-        cluster.fork();
-    }
-    if (cluster.isWorker) {
-        timer.start('loadStrapi');
-        const loadStrapiSpinner = logger.spinner(`Loading Strapi`).start();
-        const strapi = createStrapi({
-            appDir: cwd,
-            distDir: tsconfig?.config.options.outDir ?? '',
-            autoReload: true,
-            serveAdminPanel: !watchAdmin
-        });
-        /**
-     * If we're watching the admin panel then we're going to attach the watcher
-     * as a strapi middleware.
-     */ let bundleWatcher;
-        const strapiInstance = await strapi.load();
-        if (watchAdmin) {
-            timer.start('createBuildContext');
-            const contextSpinner = logger.spinner(`Building build context`).start();
-            console.log('');
-            const ctx = await createBuildContext({
-                cwd,
-                logger,
-                strapi,
-                tsconfig,
-                options
-            });
-            const contextDuration = timer.end('createBuildContext');
-            contextSpinner.text = `Building build context (${prettyTime(contextDuration)})`;
-            contextSpinner.succeed();
-            timer.start('creatingAdmin');
-            const adminSpinner = logger.spinner(`Creating admin`).start();
-            await writeStaticClientFiles(ctx);
-            if (ctx.bundler === 'webpack') {
-                const { watch: watchWebpack } = await import('./watch-DQJ0HV0l.mjs');
-                bundleWatcher = await watchWebpack(ctx);
-            } else if (ctx.bundler === 'vite') {
-                const { watch: watchVite } = await import('./watch-BDsNoG4h.mjs');
-                bundleWatcher = await watchVite(ctx);
-            }
-            const adminDuration = timer.end('creatingAdmin');
-            adminSpinner.text = `Creating admin (${prettyTime(adminDuration)})`;
-            adminSpinner.succeed();
-        }
-        const loadStrapiDuration = timer.end('loadStrapi');
-        loadStrapiSpinner.text = `Loading Strapi (${prettyTime(loadStrapiDuration)})`;
-        loadStrapiSpinner.succeed();
-        // For TS projects, type generation is a requirement for the develop command so that the server can restart
-        // For JS projects, we respect the experimental autogenerate setting
-        if (tsconfig?.config || strapi.config.get('typescript.autogenerate') !== false) {
-            timer.start('generatingTS');
-            const generatingTsSpinner = logger.spinner(`Generating types`).start();
-            await tsUtils.generators.generate({
-                strapi: strapiInstance,
-                pwd: cwd,
-                rootDir: undefined,
-                logger: {
-                    silent: true,
-                    debug: false
-                },
-                artifacts: {
-                    contentTypes: true,
-                    components: true
-                }
-            });
-            const generatingDuration = timer.end('generatingTS');
-            generatingTsSpinner.text = `Generating types (${prettyTime(generatingDuration)})`;
-            generatingTsSpinner.succeed();
-        }
-        if (tsconfig?.config) {
-            timer.start('compilingTS');
-            const compilingTsSpinner = logger.spinner(`Compiling TS`).start();
-            await cleanupDistDirectory({
-                tsconfig,
-                logger,
-                timer
-            });
-            await tsUtils.compile(cwd, {
-                configOptions: {
-                    ignoreDiagnostics: false
-                }
-            });
-            const compilingDuration = timer.end('compilingTS');
-            compilingTsSpinner.text = `Compiling TS (${prettyTime(compilingDuration)})`;
-            compilingTsSpinner.succeed();
-        }
-        const restart = async ()=>{
-            if (strapiInstance.reload.isWatching && !strapiInstance.reload.isReloading) {
-                strapiInstance.reload.isReloading = true;
-                strapiInstance.reload();
-            }
-        };
-        const watcher = chokidar.watch(cwd, {
-            ignoreInitial: true,
-            usePolling: polling,
-            ignored: [
-                /(^|[/\\])\../,
-                /tmp/,
-                '**/src/admin/**',
-                '**/src/plugins/**/admin/**',
-                '**/dist/src/plugins/test/admin/**',
-                '**/documentation',
-                '**/documentation/**',
-                '**/node_modules',
-                '**/node_modules/**',
-                '**/plugins.json',
-                '**/build',
-                '**/build/**',
-                '**/log',
-                '**/log/**',
-                '**/logs',
-                '**/logs/**',
-                '**/*.log',
-                '**/index.html',
-                '**/public',
-                '**/public/**',
-                strapiInstance.dirs.static.public,
-                strings.joinBy('/', strapiInstance.dirs.static.public, '**'),
-                '**/*.db*',
-                '**/exports/**',
-                '**/dist/**',
-                '**/*.d.ts',
-                '**/.yalc/**',
-                '**/yalc.lock',
-                // TODO v6: watch only src folder by default, and flip this to watchIncludeFiles
-                ...strapiInstance.config.get('admin.watchIgnoreFiles', [])
-            ]
-        }).on('add', (path)=>{
-            strapiInstance.log.info(`File created: ${path}`);
-            restart();
-        }).on('change', (path)=>{
-            strapiInstance.log.info(`File changed: ${path}`);
-            restart();
-        }).on('unlink', (path)=>{
-            strapiInstance.log.info(`File deleted: ${path}`);
-            restart();
-        });
-        process.on('message', async (message)=>{
-            switch(message){
-                case 'kill':
-                    {
-                        logger.debug('child process has the kill message, destroying the strapi instance and sending the killed process message');
-                        await watcher.close();
-                        await strapiInstance.destroy();
-                        if (bundleWatcher) {
-                            bundleWatcher.close();
-                        }
-                        process.send?.('killed');
-                        break;
-                    }
-            }
-        });
-        strapiInstance.start();
-    }
-};
-
-const action$5 = async (options)=>{
-    try {
-        if (cluster.isPrimary) {
-            if (options.bundler === 'webpack') {
-                options.logger.warn('[@strapi/strapi]: Using webpack as a bundler is deprecated. You should migrate to vite.');
-            }
-        }
-        await develop(options);
-    } catch (err) {
-        handleUnexpectedError(err);
-    }
-};
-/**
- * `$ strapi develop`
- */ const command$7 = ({ ctx })=>{
-    return createCommand('develop').alias('dev').option('--bundler [bundler]', 'Bundler to use (webpack or vite)', 'vite').option('-d, --debug', 'Enable debugging mode with verbose logs', false).option('--silent', "Don't log anything", false).option('--polling', 'Watch for file changes in network directories', false).option('--watch-admin', 'Watch the admin panel for hot changes', true).option('--no-watch-admin', 'Do not watch the admin panel for hot changes').option('--open', 'Open the admin in your browser', true).description('Start your Strapi application in development mode').action(async (options)=>{
-        return action$5({
-            ...options,
-            ...ctx
-        });
-    });
-};
-
-/**
- * `$ strapi generate`
- */ const command$6 = ({ argv })=>{
-    return createCommand('generate').description('Launch the interactive API generator').action(()=>{
-        assertCwdContainsStrapiProject('generate');
-        argv.splice(2, 1);
-        // NOTE: this needs to be lazy loaded in order for plop to work correctly
-        import('@strapi/generators').then((gen)=>gen.runCLI());
-    });
-};
-
-const action$4 = async ({ uuid, dependencies, all })=>{
-    const config = {
-        reportUUID: Boolean(all || uuid),
-        reportDependencies: Boolean(all || dependencies)
-    };
-    const appContext = await compileStrapi();
-    const app = await createStrapi(appContext).register();
-    let debugInfo = `Launched In: ${Date.now() - app.config.launchedAt} ms
-Environment: ${app.config.environment}
-OS: ${process.platform}-${process.arch}
-Strapi Version: ${app.config.info.strapi}
-Node/Yarn Version: ${process.env.npm_config_user_agent}
-Edition: ${app.EE ? 'Enterprise' : 'Community'}
-Database: ${app?.config?.database?.connection?.client ?? 'unknown'}`;
-    if (config.reportUUID) {
-        debugInfo += `${EOL}UUID: ${app.config.uuid}`;
-    }
-    if (config.reportDependencies) {
-        debugInfo += `${EOL}Dependencies: ${JSON.stringify(app.config.info.dependencies, null, 2)}
-Dev Dependencies: ${JSON.stringify(app.config.info.devDependencies, null, 2)}`;
-    }
-    console.log(debugInfo);
-    await app.destroy();
-};
-/**
- * `$ strapi report`
- */ const command$5 = ()=>{
-    return createCommand('report').description('Get system stats for debugging and submitting issues').option('-u, --uuid', 'Include Project UUID').option('-d, --dependencies', 'Include Project Dependencies').option('--all', 'Include All Information').action(runAction('report', action$4));
-};
-
-const action$3 = async ()=>{
-    const appDir = process.cwd();
-    const isTSProject = await tsUtils__default.isUsingTypeScript(appDir);
-    const outDir = await tsUtils__default.resolveOutDir(appDir);
-    const distDir = isTSProject ? outDir : appDir;
-    const buildDirExists = fs.existsSync(outDir);
-    if (isTSProject && !buildDirExists) throw new Error(`${outDir} directory not found. Please run the build command before starting your application`);
-    createStrapi({
-        appDir,
-        distDir
-    }).start();
-};
-/**
- * `$ strapi start`
- */ const command$4 = ()=>{
-    return createCommand('start').description('Start your Strapi application').action(runAction('start', action$3));
-};
-
-var version = "5.11.3";
-
-/**
- * `$ strapi version`
- */ const command$3 = ()=>{
-    // load the Strapi package.json to get version and other information
-    return createCommand('version').description('Output the version of Strapi').action(()=>{
-        process.stdout.write(`${version}\n`);
-        process.exit(0);
-    });
-};
-
-/**
- * argParser: Parse a comma-delimited string as an array
- */ const parseList = (value)=>{
-    try {
-        return value.split(',').map((item)=>item.trim()); // trim shouldn't be necessary but might help catch unexpected whitespace characters
-    } catch (e) {
-        exitWith(1, `Unrecognized input: ${value}`);
-    }
-    return [];
-};
-/**
- * Returns an argParser that returns a list
- */ const getParseListWithChoices = (choices, errorMessage = 'Invalid options:')=>{
-    return (value)=>{
-        const list = parseList(value);
-        const invalid = list.filter((item)=>{
-            return !choices.includes(item);
-        });
-        if (invalid.length > 0) {
-            exitWith(1, `${errorMessage}: ${invalid.join(',')}`);
-        }
-        return list;
-    };
-};
-/**
- * argParser: Parse a string as an integer
- */ const parseInteger = (value)=>{
-    // parseInt takes a string and a radix
-    const parsedValue = parseInt(value, 10);
-    if (isNaN(parsedValue)) {
-        throw new InvalidOptionArgumentError(`Not an integer: ${value}`);
-    }
-    return parsedValue;
-};
-/**
- * argParser: Parse a string as a URL object
- */ const parseURL = (value)=>{
-    try {
-        const url = new URL(value);
-        if (!url.host) {
-            throw new InvalidOptionArgumentError(`Could not parse url ${value}`);
-        }
-        return url;
-    } catch (e) {
-        throw new InvalidOptionArgumentError(`Could not parse url ${value}`);
-    }
-};
-/**
- * hook: if encrypt==true and key not provided, prompt for it
- */ const promptEncryptionKey = async (thisCommand)=>{
-    const opts = thisCommand.opts();
-    if (!opts.encrypt && opts.key) {
-        return exitWith(1, 'Key may not be present unless encryption is used');
-    }
-    // if encrypt==true but we have no key, prompt for it
-    if (opts.encrypt && !(opts.key && opts.key.length > 0)) {
-        try {
-            const answers = await inquirer.prompt([
-                {
-                    type: 'password',
-                    message: 'Please enter an encryption key',
-                    name: 'key',
-                    validate (key) {
-                        if (key.length > 0) return true;
-                        return 'Key must be present when using the encrypt option';
-                    }
-                }
-            ]);
-            opts.key = answers.key;
-        } catch (e) {
-            return exitWith(1, 'Failed to get encryption key');
-        }
-        if (!opts.key) {
-            return exitWith(1, 'Failed to get encryption key');
-        }
-    }
-};
-/**
- * hook: require a confirmation message to be accepted unless forceOption (-f,--force) is used
- */ const getCommanderConfirmMessage = (message, { failMessage } = {})=>{
-    return async (command)=>{
-        const confirmed = await confirmMessage(message, {
-            force: command.opts().force
-        });
-        if (!confirmed) {
-            exitWith(1, failMessage);
-        }
-    };
-};
-const confirmMessage = async (message, { force } = {})=>{
-    // if we have a force option, respond yes
-    if (force === true) {
-        // attempt to mimic the inquirer prompt exactly
-        console.log(`${chalk.green('?')} ${chalk.bold(message)} ${chalk.cyan('Yes')}`);
-        return true;
-    }
-    const answers = await inquirer.prompt([
-        {
-            type: 'confirm',
-            message,
-            name: `confirm`,
-            default: false
-        }
-    ]);
-    return answers.confirm;
-};
-const forceOption = new Option('--force', `Automatically answer "yes" to all prompts, including potentially destructive requests, and run non-interactively.`);
-
-const { errors: { TransferEngineInitializationError } } = engine;
-const exitMessageText = (process1, error = false)=>{
-    const processCapitalized = process1[0].toUpperCase() + process1.slice(1);
-    if (!error) {
-        return chalk.bold(chalk.green(`${processCapitalized} process has been completed successfully!`));
-    }
-    return chalk.bold(chalk.red(`${processCapitalized} process failed.`));
-};
-const pad = (n)=>{
-    return (n < 10 ? '0' : '') + String(n);
-};
-const yyyymmddHHMMSS = ()=>{
-    const date = new Date();
-    return date.getFullYear() + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
-};
-const getDefaultExportName = ()=>{
-    return `export_${yyyymmddHHMMSS()}`;
-};
-const buildTransferTable = (resultData)=>{
-    if (!resultData) {
-        return;
-    }
-    // Build pretty table
-    const table = new CLITable({
-        head: [
-            'Type',
-            'Count',
-            'Size'
-        ].map((text)=>chalk.bold.blue(text))
-    });
-    let totalBytes = 0;
-    let totalItems = 0;
-    Object.keys(resultData).forEach((stage)=>{
-        const item = resultData[stage];
-        if (!item) {
-            return;
-        }
-        table.push([
-            {
-                hAlign: 'left',
-                content: chalk.bold(stage)
-            },
-            {
-                hAlign: 'right',
-                content: item.count
-            },
-            {
-                hAlign: 'right',
-                content: `${readableBytes(item.bytes, 1, 11)} `
-            }
-        ]);
-        totalBytes += item.bytes;
-        totalItems += item.count;
-        if (item.aggregates) {
-            Object.keys(item.aggregates).sort().forEach((subkey)=>{
-                if (!item.aggregates) {
-                    return;
-                }
-                const subitem = item.aggregates[subkey];
-                table.push([
-                    {
-                        hAlign: 'left',
-                        content: `-- ${chalk.bold.grey(subkey)}`
-                    },
-                    {
-                        hAlign: 'right',
-                        content: chalk.grey(subitem.count)
-                    },
-                    {
-                        hAlign: 'right',
-                        content: chalk.grey(`(${readableBytes(subitem.bytes, 1, 11)})`)
-                    }
-                ]);
-            });
-        }
-    });
-    table.push([
-        {
-            hAlign: 'left',
-            content: chalk.bold.green('Total')
-        },
-        {
-            hAlign: 'right',
-            content: chalk.bold.green(totalItems)
-        },
-        {
-            hAlign: 'right',
-            content: `${chalk.bold.green(readableBytes(totalBytes, 1, 11))} `
-        }
-    ]);
-    return table;
-};
-const DEFAULT_IGNORED_CONTENT_TYPES = [
-    'admin::permission',
-    'admin::user',
-    'admin::role',
-    'admin::api-token',
-    'admin::api-token-permission',
-    'admin::transfer-token',
-    'admin::transfer-token-permission',
-    'admin::audit-log',
-    'plugin::content-releases.release',
-    'plugin::content-releases.release-action'
-];
-const abortTransfer = async ({ engine, strapi: strapi1 })=>{
-    try {
-        await engine.abortTransfer();
-        await strapi1.destroy();
-    } catch (e) {
-        // ignore because there's not much else we can do
-        return false;
-    }
-    return true;
-};
-const setSignalHandler = async (handler, signals = [
-    'SIGINT',
-    'SIGTERM',
-    'SIGQUIT'
-])=>{
-    signals.forEach((signal)=>{
-        // We specifically remove ALL listeners because we have to clear the one added in Strapi bootstrap that has a process.exit
-        // TODO: Ideally Strapi bootstrap would not add that listener, and then this could be more flexible and add/remove only what it needs to
-        process.removeAllListeners(signal);
-        process.on(signal, handler);
-    });
-};
-const createStrapiInstance = async (opts = {})=>{
-    try {
-        const appContext = await compileStrapi();
-        const app = createStrapi({
-            ...opts,
-            ...appContext
-        });
-        app.log.level = opts.logLevel || 'error';
-        return await app.load();
-    } catch (error) {
-        if (error instanceof Error && 'code' in error && error.code === 'ECONNREFUSED') {
-            throw new Error('Process failed. Check the database connection with your Strapi project.');
-        }
-        throw error;
-    }
-};
-const transferDataTypes = Object.keys(engine.TransferGroupPresets);
-const throttleOption = new Option('--throttle <delay after each entity>', `Add a delay in milliseconds between each transferred entity`).argParser(parseInteger).hideHelp(); // This option is not publicly documented
-const excludeOption = new Option('--exclude <comma-separated data types>', `Exclude data using comma-separated types. Available types: ${transferDataTypes.join(',')}`).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "exclude"'));
-const onlyOption = new Option('--only <command-separated data types>', `Include only these types of data (plus schemas). Available types: ${transferDataTypes.join(',')}`).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "only"'));
-const validateExcludeOnly = (command)=>{
-    const { exclude, only } = command.opts();
-    if (!only || !exclude) {
-        return;
-    }
-    const choicesInBoth = only.filter((n)=>{
-        return exclude.indexOf(n) !== -1;
-    });
-    if (choicesInBoth.length > 0) {
-        exitWith(1, `Data types may not be used in both "exclude" and "only" in the same command. Found in both: ${choicesInBoth.join(',')}`);
-    }
-};
-const errorColors = {
-    fatal: chalk.red,
-    error: chalk.red,
-    silly: chalk.yellow
-};
-const formatDiagnostic = (operation, info)=>{
-    // Create log file for all incoming diagnostics
-    let logger;
-    const getLogger = ()=>{
-        if (!logger) {
-            logger = createLogger$1(configs.createOutputFileConfiguration(`${operation}_${Date.now()}.log`, {
-                level: 'info',
-                format: formats?.detailedLogs
-            }));
-        }
-        return logger;
-    };
-    // We don't want to write a log file until there is something to be logged
-    return ({ details, kind })=>{
-        try {
-            if (kind === 'error') {
-                const { message, severity = 'fatal' } = details;
-                const colorizeError = errorColors[severity];
-                const errorMessage = colorizeError(`[${severity.toUpperCase()}] ${message}`);
-                getLogger().error(errorMessage);
-            }
-            if (kind === 'info' && info) {
-                const { message, params, origin } = details;
-                const msg = `[${origin ?? 'transfer'}] ${message}\n${params ? JSON.stringify(params, null, 2) : ''}`;
-                getLogger().info(msg);
-            }
-            if (kind === 'warning') {
-                const { origin, message } = details;
-                getLogger().warn(`(${origin ?? 'transfer'}) ${message}`);
-            }
-        } catch (err) {
-            getLogger().error(err);
-        }
-    };
-};
-const loadersFactory = (defaultLoaders = {})=>{
-    const loaders = defaultLoaders;
-    const updateLoader = (stage, data)=>{
-        if (!(stage in loaders)) {
-            createLoader(stage);
-        }
-        const stageData = data[stage];
-        const elapsedTime = stageData?.startTime ? (stageData?.endTime || Date.now()) - stageData.startTime : 0;
-        const size = `size: ${readableBytes(stageData?.bytes ?? 0)}`;
-        const elapsed = `elapsed: ${elapsedTime} ms`;
-        const speed = elapsedTime > 0 ? `(${readableBytes((stageData?.bytes ?? 0) * 1000 / elapsedTime)}/s)` : '';
-        loaders[stage].text = `${stage}: ${stageData?.count ?? 0} transfered (${size}) (${elapsed}) ${!stageData?.endTime ? speed : ''}`;
-        return loaders[stage];
-    };
-    const createLoader = (stage)=>{
-        Object.assign(loaders, {
-            [stage]: ora()
-        });
-        return loaders[stage];
-    };
-    const getLoader = (stage)=>{
-        return loaders[stage];
-    };
-    return {
-        updateLoader,
-        createLoader,
-        getLoader
-    };
-};
-/**
- * Get the telemetry data to be sent for a didDEITSProcess* event from an initialized transfer engine object
- */ const getTransferTelemetryPayload = (engine)=>{
-    return {
-        eventProperties: {
-            source: engine?.sourceProvider?.name,
-            destination: engine?.destinationProvider?.name
-        }
-    };
-};
-/**
- * Get a transfer engine schema diff handler that confirms with the user before bypassing a schema check
- */ const getDiffHandler = (engine, { force, action })=>{
-    return async (context, next)=>{
-        // if we abort here, we need to actually exit the process because of conflict with inquirer prompt
-        setSignalHandler(async ()=>{
-            await abortTransfer({
-                engine,
-                strapi: strapi
-            });
-            exitWith(1, exitMessageText(action, true));
-        });
-        let workflowsStatus;
-        const source = 'Schema Integrity';
-        Object.entries(context.diffs).forEach(([uid, diffs])=>{
-            for (const diff of diffs){
-                const path = [
-                    uid
-                ].concat(diff.path).join('.');
-                const endPath = diff.path[diff.path.length - 1];
-                // Catch known features
-                if (uid === 'plugin::review-workflows.workflow' || uid === 'plugin::review-workflows.workflow-stage' || endPath?.startsWith('strapi_stage') || endPath?.startsWith('strapi_assignee')) {
-                    workflowsStatus = diff.kind;
-                } else if (diff.kind === 'added') {
-                    engine.reportWarning(chalk.red(`${chalk.bold(path)} does not exist on source`), source);
-                } else if (diff.kind === 'deleted') {
-                    engine.reportWarning(chalk.red(`${chalk.bold(path)} does not exist on destination`), source);
-                } else if (diff.kind === 'modified') {
-                    engine.reportWarning(chalk.red(`${chalk.bold(path)} has a different data type`), source);
-                }
-            }
-        });
-        // output the known feature warnings
-        if (workflowsStatus === 'added') {
-            engine.reportWarning(chalk.red(`Review workflows feature does not exist on source`), source);
-        } else if (workflowsStatus === 'deleted') {
-            engine.reportWarning(chalk.red(`Review workflows feature does not exist on destination`), source);
-        } else if (workflowsStatus === 'modified') {
-            engine.panic(new TransferEngineInitializationError('Unresolved differences in schema [review workflows]'));
-        }
-        const confirmed = await confirmMessage('There are differences in schema between the source and destination, and the data listed above will be lost. Are you sure you want to continue?', {
-            force
-        });
-        // reset handler back to normal
-        setSignalHandler(()=>abortTransfer({
-                engine,
-                strapi: strapi
-            }));
-        if (confirmed) {
-            context.ignoredDiffs = merge(context.diffs, context.ignoredDiffs);
-        }
-        return next(context);
-    };
-};
-const getAssetsBackupHandler = (engine, { force, action })=>{
-    return async (context, next)=>{
-        // if we abort here, we need to actually exit the process because of conflict with inquirer prompt
-        setSignalHandler(async ()=>{
-            await abortTransfer({
-                engine,
-                strapi: strapi
-            });
-            exitWith(1, exitMessageText(action, true));
-        });
-        console.warn('The backup for the assets could not be created inside the public directory. Ensure Strapi has write permissions on the public directory.');
-        const confirmed = await confirmMessage('Do you want to continue without backing up your public/uploads files?', {
-            force
-        });
-        if (confirmed) {
-            context.ignore = true;
-        }
-        // reset handler back to normal
-        setSignalHandler(()=>abortTransfer({
-                engine,
-                strapi: strapi
-            }));
-        return next(context);
-    };
-};
-const shouldSkipStage = (opts, dataKind)=>{
-    if (opts.exclude?.includes(dataKind)) {
-        return true;
-    }
-    if (opts.only) {
-        return !opts.only.includes(dataKind);
-    }
-    return false;
-};
-// Based on exclude/only from options, create the restore object to match
-const parseRestoreFromOptions = (opts)=>{
-    const entitiesOptions = {
-        exclude: DEFAULT_IGNORED_CONTENT_TYPES,
-        include: undefined
-    };
-    // if content is not included, send an empty array for include
-    if (opts.only && !opts.only.includes('content') || opts.exclude?.includes('content')) {
-        entitiesOptions.include = [];
-    }
-    const restoreConfig = {
-        entities: entitiesOptions,
-        assets: !shouldSkipStage(opts, 'files'),
-        configuration: {
-            webhook: !shouldSkipStage(opts, 'config'),
-            coreStore: !shouldSkipStage(opts, 'config')
-        }
-    };
-    return restoreConfig;
-};
-
-const { providers: { createLocalFileDestinationProvider } } = file;
-const { providers: { createLocalStrapiSourceProvider: createLocalStrapiSourceProvider$1 } } = strapi$1;
-const BYTES_IN_MB = 1024 * 1024;
-/**
- * Export command.
- *
- * It transfers data from a local Strapi instance to a file
- *
- * @param {ExportCommandOptions} opts
- */ var action$2 = (async (opts)=>{
-    // Validate inputs from Commander
-    if (!isObject(opts)) {
-        exitWith(1, 'Could not parse command arguments');
-    }
-    const strapi = await createStrapiInstance();
-    const source = createSourceProvider(strapi);
-    const destination = createDestinationProvider(opts);
-    const engine$1 = engine.createTransferEngine(source, destination, {
-        versionStrategy: 'ignore',
-        schemaStrategy: 'ignore',
-        exclude: opts.exclude,
-        only: opts.only,
-        throttle: opts.throttle,
-        transforms: {
-            links: [
-                {
-                    filter (link) {
-                        return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type);
-                    }
-                }
-            ],
-            entities: [
-                {
-                    filter (entity) {
-                        return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type);
-                    }
-                }
-            ]
-        }
-    });
-    engine$1.diagnostics.onDiagnostic(formatDiagnostic('export', opts.verbose));
-    const progress = engine$1.progress.stream;
-    const { updateLoader } = loadersFactory();
-    progress.on(`stage::start`, ({ stage, data })=>{
-        updateLoader(stage, data).start();
-    });
-    progress.on('stage::finish', ({ stage, data })=>{
-        updateLoader(stage, data).succeed();
-    });
-    progress.on('stage::progress', ({ stage, data })=>{
-        updateLoader(stage, data);
-    });
-    progress.on('transfer::start', async ()=>{
-        console.log(`Starting export...`);
-        await strapi.telemetry.send('didDEITSProcessStart', getTransferTelemetryPayload(engine$1));
-    });
-    let results;
-    let outFile;
-    try {
-        // Abort transfer if user interrupts process
-        setSignalHandler(()=>abortTransfer({
-                engine: engine$1,
-                strapi
-            }));
-        results = await engine$1.transfer();
-        outFile = results.destination?.file?.path ?? '';
-        const outFileExists = await fse.pathExists(outFile);
-        if (!outFileExists) {
-            throw new engine.errors.TransferEngineTransferError(`Export file not created "${outFile}"`);
-        }
-        // Note: we need to await telemetry or else the process ends before it is sent
-        await strapi.telemetry.send('didDEITSProcessFinish', getTransferTelemetryPayload(engine$1));
-        try {
-            const table = buildTransferTable(results.engine);
-            console.log(table?.toString());
-        } catch (e) {
-            console.error('There was an error displaying the results of the transfer.');
-        }
-        console.log(`Export archive is in ${chalk.green(outFile)}`);
-        exitWith(0, exitMessageText('export'));
-    } catch  {
-        await strapi.telemetry.send('didDEITSProcessFail', getTransferTelemetryPayload(engine$1));
-        exitWith(1, exitMessageText('export', true));
-    }
-});
-/**
- * It creates a local strapi destination provider
- */ const createSourceProvider = (strapi)=>{
-    return createLocalStrapiSourceProvider$1({
-        async getStrapi () {
-            return strapi;
-        }
-    });
-};
-/**
- * It creates a local file destination provider based on the given options
- */ const createDestinationProvider = (opts)=>{
-    const { file, compress, encrypt, key, maxSizeJsonl } = opts;
-    const filepath = isString(file) && file.length > 0 ? file : getDefaultExportName();
-    const maxSizeJsonlInMb = isFinite(toNumber(maxSizeJsonl)) ? toNumber(maxSizeJsonl) * BYTES_IN_MB : undefined;
-    return createLocalFileDestinationProvider({
-        file: {
-            path: filepath,
-            maxSizeJsonl: maxSizeJsonlInMb
-        },
-        encryption: {
-            enabled: encrypt ?? false,
-            key: encrypt ? key : undefined
-        },
-        compression: {
-            enabled: compress ?? false
-        }
-    });
-};
-
-/**
- * `$ strapi export`
- */ const command$2 = ()=>{
-    return createCommand('export').description('Export data from Strapi to file').allowExcessArguments(false).addOption(new Option('--no-encrypt', `Disables 'aes-128-ecb' encryption of the output file`).default(true)).addOption(new Option('--no-compress', 'Disables gzip compression of output file').default(true)).addOption(new Option('--verbose', 'Enable verbose logs')).addOption(new Option('-k, --key <string>', 'Provide encryption key in command instead of using the prompt')).addOption(new Option('-f, --file <file>', 'name to use for exported file (without extensions)')).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook('preAction', validateExcludeOnly).hook('preAction', promptEncryptionKey).action(action$2);
-};
-
-const { providers: { createLocalFileSourceProvider } } = file;
-const { providers: { createLocalStrapiDestinationProvider: createLocalStrapiDestinationProvider$1, DEFAULT_CONFLICT_STRATEGY } } = strapi$1;
-const { createTransferEngine: createTransferEngine$1, DEFAULT_VERSION_STRATEGY, DEFAULT_SCHEMA_STRATEGY } = engine;
-/**
- * Import command.
- *
- * It transfers data from a file to a local Strapi instance
- */ var action$1 = (async (opts)=>{
-    // validate inputs from Commander
-    if (!isObject(opts)) {
-        exitWith(1, 'Could not parse arguments');
-    }
-    /**
-   * From strapi backup file
-   */ const sourceOptions = getLocalFileSourceOptions(opts);
-    const source = createLocalFileSourceProvider(sourceOptions);
-    /**
-   * To local Strapi instance
-   */ const strapiInstance = await createStrapiInstance();
-    /**
-   * Configure and run the transfer engine
-   */ const engineOptions = {
-        versionStrategy: DEFAULT_VERSION_STRATEGY,
-        schemaStrategy: DEFAULT_SCHEMA_STRATEGY,
-        exclude: opts.exclude,
-        only: opts.only,
-        throttle: opts.throttle,
-        transforms: {
-            links: [
-                {
-                    filter (link) {
-                        return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type);
-                    }
-                }
-            ],
-            entities: [
-                {
-                    filter: (entity)=>!DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type)
-                }
-            ]
-        }
-    };
-    const destinationOptions = {
-        async getStrapi () {
-            return strapiInstance;
-        },
-        autoDestroy: false,
-        strategy: opts.conflictStrategy || DEFAULT_CONFLICT_STRATEGY,
-        restore: parseRestoreFromOptions(engineOptions)
-    };
-    const destination = createLocalStrapiDestinationProvider$1(destinationOptions);
-    destination.onWarning = (message)=>console.warn(`\n${chalk.yellow('warn')}: ${message}`);
-    const engine = createTransferEngine$1(source, destination, engineOptions);
-    engine.diagnostics.onDiagnostic(formatDiagnostic('import', opts.verbose));
-    const progress = engine.progress.stream;
-    const { updateLoader } = loadersFactory();
-    engine.onSchemaDiff(getDiffHandler(engine, {
-        force: opts.force,
-        action: 'import'
-    }));
-    progress.on(`stage::start`, ({ stage, data })=>{
-        updateLoader(stage, data).start();
-    });
-    progress.on('stage::finish', ({ stage, data })=>{
-        updateLoader(stage, data).succeed();
-    });
-    progress.on('stage::progress', ({ stage, data })=>{
-        updateLoader(stage, data);
-    });
-    progress.on('transfer::start', async ()=>{
-        console.log('Starting import...');
-        await strapiInstance.telemetry.send('didDEITSProcessStart', getTransferTelemetryPayload(engine));
-    });
-    let results;
-    try {
-        // Abort transfer if user interrupts process
-        setSignalHandler(()=>abortTransfer({
-                engine,
-                strapi: strapi
-            }));
-        results = await engine.transfer();
-        try {
-            const table = buildTransferTable(results.engine);
-            console.log(table?.toString());
-        } catch (e) {
-            console.error('There was an error displaying the results of the transfer.');
-        }
-        // Note: we need to await telemetry or else the process ends before it is sent
-        await strapiInstance.telemetry.send('didDEITSProcessFinish', getTransferTelemetryPayload(engine));
-        await strapiInstance.destroy();
-        exitWith(0, exitMessageText('import'));
-    } catch (e) {
-        await strapiInstance.telemetry.send('didDEITSProcessFail', getTransferTelemetryPayload(engine));
-        exitWith(1, exitMessageText('import', true));
-    }
-});
-/**
- * Infer local file source provider options based on a given filename
- */ const getLocalFileSourceOptions = (opts)=>{
-    const options = {
-        file: {
-            path: opts.file ?? ''
-        },
-        compression: {
-            enabled: !!opts.decompress
-        },
-        encryption: {
-            enabled: !!opts.decrypt,
-            key: opts.key
-        }
-    };
-    return options;
-};
-
-/**
- * `$ strapi import`
- */ const command$1 = ()=>{
-    return createCommand('import').description('Import data from file to Strapi').allowExcessArguments(false).requiredOption('-f, --file <file>', 'path and filename for the Strapi export file you want to import').addOption(new Option('-k, --key <string>', 'Provide encryption key in command instead of using the prompt')).addOption(new Option('--verbose', 'Enable verbose logs')).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook('preAction', validateExcludeOnly).hook('preAction', async (thisCommand)=>{
-        const opts = thisCommand.opts();
-        const ext = path$1.extname(String(opts.file));
-        // check extension to guess if we should prompt for key
-        if (ext === '.enc') {
-            if (!opts.key) {
-                const answers = await inquirer.prompt([
-                    {
-                        type: 'password',
-                        message: 'Please enter your decryption key',
-                        name: 'key'
-                    }
-                ]);
-                if (!answers.key?.length) {
-                    exitWith(1, 'No key entered, aborting import.');
-                }
-                opts.key = answers.key;
-            }
-        }
-    })// set decrypt and decompress options based on filename
-    .hook('preAction', (thisCommand)=>{
-        const opts = thisCommand.opts();
-        const { extname, parse } = path$1;
-        let file = opts.file;
-        if (extname(file) === '.enc') {
-            file = parse(file).name; // trim the .enc extension
-            thisCommand.opts().decrypt = true;
-        } else {
-            thisCommand.opts().decrypt = false;
-        }
-        if (extname(file) === '.gz') {
-            file = parse(file).name; // trim the .gz extension
-            thisCommand.opts().decompress = true;
-        } else {
-            thisCommand.opts().decompress = false;
-        }
-        if (extname(file) !== '.tar') {
-            exitWith(1, `The file '${opts.file}' does not appear to be a valid Strapi data file. It must have an extension ending in .tar[.gz][.enc]`);
-        }
-    }).hook('preAction', getCommanderConfirmMessage('The import will delete your existing data! Are you sure you want to proceed?', {
-        failMessage: 'Import process aborted'
-    })).action(action$1);
-};
-
-const { createTransferEngine } = engine;
-const { providers: { createRemoteStrapiDestinationProvider, createLocalStrapiSourceProvider, createLocalStrapiDestinationProvider, createRemoteStrapiSourceProvider } } = strapi$1;
-/**
- * Transfer command.
- *
- * Transfers data between local Strapi and remote Strapi instances
- */ var action = (async (opts)=>{
-    // Validate inputs from Commander
-    if (!isObject(opts)) {
-        exitWith(1, 'Could not parse command arguments');
-    }
-    if (!(opts.from || opts.to) || opts.from && opts.to) {
-        exitWith(1, 'Exactly one source (from) or destination (to) option must be provided');
-    }
-    const strapi = await createStrapiInstance();
-    let source;
-    let destination;
-    // if no URL provided, use local Strapi
-    if (!opts.from) {
-        source = createLocalStrapiSourceProvider({
-            getStrapi: ()=>strapi
-        });
-    } else {
-        if (!opts.fromToken) {
-            exitWith(1, 'Missing token for remote destination');
-        }
-        source = createRemoteStrapiSourceProvider({
-            getStrapi: ()=>strapi,
-            url: opts.from,
-            auth: {
-                type: 'token',
-                token: opts.fromToken
-            }
-        });
-    }
-    // if no URL provided, use local Strapi
-    if (!opts.to) {
-        destination = createLocalStrapiDestinationProvider({
-            getStrapi: ()=>strapi,
-            strategy: 'restore',
-            restore: parseRestoreFromOptions(opts)
-        });
-    } else {
-        if (!opts.toToken) {
-            exitWith(1, 'Missing token for remote destination');
-        }
-        destination = createRemoteStrapiDestinationProvider({
-            url: opts.to,
-            auth: {
-                type: 'token',
-                token: opts.toToken
-            },
-            strategy: 'restore',
-            restore: parseRestoreFromOptions(opts)
-        });
-    }
-    if (!source || !destination) {
-        exitWith(1, 'Could not create providers');
-    }
-    const engine = createTransferEngine(source, destination, {
-        versionStrategy: 'exact',
-        schemaStrategy: 'strict',
-        exclude: opts.exclude,
-        only: opts.only,
-        throttle: opts.throttle,
-        transforms: {
-            links: [
-                {
-                    filter (link) {
-                        return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type);
-                    }
-                }
-            ],
-            entities: [
-                {
-                    filter (entity) {
-                        return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type);
-                    }
-                }
-            ]
-        }
-    });
-    engine.diagnostics.onDiagnostic(formatDiagnostic('transfer', opts.verbose));
-    const progress = engine.progress.stream;
-    const { updateLoader } = loadersFactory();
-    engine.onSchemaDiff(getDiffHandler(engine, {
-        force: opts.force,
-        action: 'transfer'
-    }));
-    engine.addErrorHandler('ASSETS_DIRECTORY_ERR', getAssetsBackupHandler(engine, {
-        force: opts.force,
-        action: 'transfer'
-    }));
-    progress.on(`stage::start`, ({ stage, data })=>{
-        updateLoader(stage, data).start();
-    });
-    progress.on('stage::finish', ({ stage, data })=>{
-        updateLoader(stage, data).succeed();
-    });
-    progress.on('stage::progress', ({ stage, data })=>{
-        updateLoader(stage, data);
-    });
-    progress.on('stage::error', ({ stage, data })=>{
-        updateLoader(stage, data).fail();
-    });
-    progress.on('transfer::start', async ()=>{
-        console.log(`Starting transfer...`);
-        await strapi.telemetry.send('didDEITSProcessStart', getTransferTelemetryPayload(engine));
-    });
-    let results;
-    try {
-        // Abort transfer if user interrupts process
-        setSignalHandler(()=>abortTransfer({
-                engine,
-                strapi
-            }));
-        results = await engine.transfer();
-        // Note: we need to await telemetry or else the process ends before it is sent
-        await strapi.telemetry.send('didDEITSProcessFinish', getTransferTelemetryPayload(engine));
-        try {
-            const table = buildTransferTable(results.engine);
-            console.log(table?.toString());
-        } catch (e) {
-            console.error('There was an error displaying the results of the transfer.');
-        }
-        exitWith(0, exitMessageText('transfer'));
-    } catch (e) {
-        await strapi.telemetry.send('didDEITSProcessFail', getTransferTelemetryPayload(engine));
-        exitWith(1, exitMessageText('transfer', true));
-    }
-});
-
-/**
- * `$ strapi transfer`
- */ const command = ()=>{
-    return createCommand('transfer').description('Transfer data from one source to another').allowExcessArguments(false).addOption(new Option('--from <sourceURL>', `URL of the remote Strapi instance to get data from`).argParser(parseURL)).addOption(new Option('--from-token <token>', `Transfer token for the remote Strapi source`)).addOption(new Option('--to <destinationURL>', `URL of the remote Strapi instance to send data to`).argParser(parseURL)).addOption(new Option('--to-token <token>', `Transfer token for the remote Strapi destination`)).addOption(new Option('--verbose', 'Enable verbose logs')).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook('preAction', validateExcludeOnly).hook('preAction', ifOptions((opts)=>!(opts.from || opts.to) || opts.from && opts.to, async ()=>exitWith(1, 'Exactly one remote source (from) or destination (to) option must be provided')))// If --from is used, validate the URL and token
-    .hook('preAction', ifOptions((opts)=>opts.from, async (thisCommand)=>{
-        assertUrlHasProtocol(thisCommand.opts().from, [
-            'https:',
-            'http:'
-        ]);
-        if (!thisCommand.opts().fromToken) {
-            const answers = await inquirer.prompt([
-                {
-                    type: 'password',
-                    message: 'Please enter your transfer token for the remote Strapi source',
-                    name: 'fromToken'
-                }
-            ]);
-            if (!answers.fromToken?.length) {
-                exitWith(1, 'No token provided for remote source, aborting transfer.');
-            }
-            thisCommand.opts().fromToken = answers.fromToken;
-        }
-        await getCommanderConfirmMessage('The transfer will delete all the local Strapi assets and its database. Are you sure you want to proceed?', {
-            failMessage: 'Transfer process aborted'
-        })(thisCommand);
-    }))// If --to is used, validate the URL, token, and confirm restore
-    .hook('preAction', ifOptions((opts)=>opts.to, async (thisCommand)=>{
-        assertUrlHasProtocol(thisCommand.opts().to, [
-            'https:',
-            'http:'
-        ]);
-        if (!thisCommand.opts().toToken) {
-            const answers = await inquirer.prompt([
-                {
-                    type: 'password',
-                    message: 'Please enter your transfer token for the remote Strapi destination',
-                    name: 'toToken'
-                }
-            ]);
-            if (!answers.toToken?.length) {
-                exitWith(1, 'No token provided for remote destination, aborting transfer.');
-            }
-            thisCommand.opts().toToken = answers.toToken;
-        }
-        await getCommanderConfirmMessage('The transfer will delete existing data from the remote Strapi! Are you sure you want to proceed?', {
-            failMessage: 'Transfer process aborted'
-        })(thisCommand);
-    })).action(action);
-};
-
-const commands = [
-    command$p,
-    command$o,
-    command$n,
-    command$m,
-    command$l,
-    command$8,
-    command$k,
-    command$j,
-    command$6,
-    command$i,
-    command$h,
-    command$g,
-    command$5,
-    command$f,
-    command$e,
-    command$4,
-    command$d,
-    command$c,
-    command$b,
-    command$a,
-    command$3,
-    command$9,
-    command$7,
-    command$2,
-    command$1,
-    command,
-    /**
-   * Cloud
-   */ buildStrapiCloudCommands
-];
-
-const silentSpinner = {
-    succeed () {
-        return this;
-    },
-    fail () {
-        return this;
-    },
-    start () {
-        return this;
-    },
-    text: '',
-    isSpinning: false
-};
-const silentProgressBar = {
-    start () {
-        return this;
-    },
-    stop () {
-        return this;
-    },
-    update () {
-        return this;
-    }
-};
-const createLogger = (options = {})=>{
-    const { silent = false, debug = false, timestamp = true } = options;
-    const state = {
-        errors: 0,
-        warning: 0
-    };
-    return {
-        get warnings () {
-            return state.warning;
-        },
-        get errors () {
-            return state.errors;
-        },
-        debug (...args) {
-            if (silent || !debug) {
-                return;
-            }
-            console.log(chalk.cyan(`[DEBUG]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        info (...args) {
-            if (silent) {
-                return;
-            }
-            console.info(chalk.blue(`[INFO]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        log (...args) {
-            if (silent) {
-                return;
-            }
-            console.info(chalk.blue(`${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        success (...args) {
-            if (silent) {
-                return;
-            }
-            console.info(chalk.green(`[SUCCESS]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        warn (...args) {
-            state.warning += 1;
-            if (silent) {
-                return;
-            }
-            console.warn(chalk.yellow(`[WARN]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        error (...args) {
-            state.errors += 1;
-            if (silent) {
-                return;
-            }
-            console.error(chalk.red(`[ERROR]${timestamp ? `\t[${new Date().toISOString()}]` : ''}`), ...args);
-        },
-        spinner (text) {
-            if (silent) {
-                return silentSpinner;
-            }
-            return ora(text);
-        },
-        progressBar (totalSize, text) {
-            if (silent) {
-                return silentProgressBar;
-            }
-            const progressBar = new cliProgress.SingleBar({
-                format: `${text ? `${text} |` : ''}${chalk.green('{bar}')}| {percentage}%`,
-                barCompleteChar: '\u2588',
-                barIncompleteChar: '\u2591',
-                hideCursor: true,
-                forceRedraw: true
-            });
-            progressBar.start(totalSize, 0);
-            return progressBar;
-        }
-    };
-};
-
-/**
- * @description Load a tsconfig.json file and return the parsed config.
- *
- * @internal
- */ const loadTsConfig = ({ cwd, path, logger })=>{
-    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, path);
-    if (!configPath) {
-        return undefined;
-    }
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
-    logger.debug(`Loaded user TS config:`, os$1.EOL, parsedConfig);
-    return {
-        config: parsedConfig,
-        path: configPath
-    };
-};
-
-const createCLI = async (argv, command = new Command())=>{
-    // Initial program setup
-    command.storeOptionsAsProperties(false).allowUnknownOption(true);
-    // Help command
-    command.helpOption('-h, --help', 'Display help for command');
-    command.addHelpCommand('help [command]', 'Display help for command');
-    command.version(version, '-v, --version', 'Output the version number');
-    const cwd = process.cwd();
-    const hasDebug = argv.includes('--debug');
-    const hasSilent = argv.includes('--silent');
-    const logger = createLogger({
-        debug: hasDebug,
-        silent: hasSilent,
-        timestamp: false
-    });
-    const tsconfig = loadTsConfig({
-        cwd,
-        path: 'tsconfig.json',
-        logger
-    });
-    const ctx = {
-        cwd,
-        logger,
-        tsconfig
-    };
-    // Load all commands
-    for (const commandFactory of commands){
-        try {
-            const subCommand = await commandFactory({
-                command,
-                argv,
-                ctx
-            });
-            // Add this command to the Commander command object
-            if (subCommand) {
-                command.addCommand(subCommand);
-            }
-        } catch (e) {
-            console.error(`Failed to load command`, e);
-        }
-    }
-    // TODO v6: remove these deprecation notices
-    const deprecatedCommands = [
-        {
-            name: 'plugin:init',
-            message: 'Please use `npx @strapi/sdk-plugin init` instead.'
-        },
-        {
-            name: 'plugin:verify',
-            message: 'After migrating your plugin to v5, use `strapi-plugin verify`'
-        },
-        {
-            name: 'plugin:watch',
-            message: 'After migrating your plugin to v5, use `strapi-plugin watch`'
-        },
-        {
-            name: 'plugin:watch:link',
-            message: 'After migrating your plugin to v5, use `strapi-plugin watch:link`'
-        },
-        {
-            name: 'plugin:build',
-            message: 'After migrating your plugin to v5, use `strapi-plugin build`'
-        }
-    ];
-    // Add hidden commands for deprecatedCommands that output a warning that the command has been removed.
-    deprecatedCommands.forEach(({ name, message })=>{
-        const deprecated = new Command(name).command(name).description('(deprecated)').action(()=>{
-            console.warn(`The command ${name} has been deprecated. See the Strapi 5 migration guide for more information.`);
-            if (message) {
-                console.warn(message);
-            }
-        });
-        command.addCommand(deprecated, {
-            hidden: true
-        });
-    });
-    return command;
-};
-const runCLI = async (argv = process.argv, command = new Command())=>{
-    const commands = await createCLI(argv, command);
-    await commands.parseAsync(argv);
-};
-
-export { createCLI as c, getDocumentHTML as g, isError as i, loadFile as l, runCLI as r };
-//# sourceMappingURL=index-DL_emYoN.mjs.map