@servicetitan/startup 35.2.0-far-1776.0 → 35.2.0

package/dist/cli/commands/registry/command-registry.d.ts

@@ -0,0 +1,509 @@
+import { Command, CommandEntry, Newable } from '../types';
+export interface CommandRegistryEntry extends CommandEntry {
+    load: () => Promise<Newable<Command>>;
+}
+export declare const commandRegistry: {
+    "upload-sourcemaps": {
+        options: {
+            dry: {
+                boolean: true;
+                description: string;
+            };
+            releaseVersion: {
+                string: true;
+                demandOption: true;
+                requiresArg: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    test: {
+        description: string;
+        greedy: true;
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            runner: {
+                choices: readonly ["jest", "vitest"];
+                description: string;
+                defaultDescription: string;
+            };
+            runnerArgs: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    task: {
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            taskName: {
+                string: true;
+                hidden: true;
+            };
+            taskArgs: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    "styles-check": CommandRegistryEntry;
+    stylelint: {
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            fix: {
+                boolean: true;
+                hidden: true;
+            };
+            paths: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    start: {
+        description: string;
+        greedy: true;
+        options: {
+            codeCoverage: {
+                boolean: true;
+                description: string;
+            };
+            config: {
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            ignore: {
+                array: true;
+                string: true;
+                description: string;
+            };
+            scope: {
+                array: true;
+                string: true;
+                description: string;
+            };
+            useTsc: {
+                boolean: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    review: {
+        allowRunFromGlobal: true;
+        description: string;
+        options: {
+            fix: {
+                boolean: true;
+                description: string;
+            };
+            rule: {
+                array: true;
+                string: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "prepare-package": {
+        options: {
+            watch: {
+                boolean: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-purge-cache": {
+        options: {
+            host: {
+                string: true;
+                description: string;
+                demandOption: true;
+            };
+            packageName: {
+                string: true;
+                description: string;
+                demandOption: true;
+            };
+            tag: {
+                string: true;
+                description: string;
+                demandOption: true;
+            };
+            token: {
+                string: true;
+                description: string;
+                defaultDescription: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-publish": {
+        description: string;
+        options: {
+            clean: {
+                boolean: true;
+                description: string;
+            };
+            concurrency: {
+                number: true;
+                description: string;
+                defaultDescription: string;
+            };
+            rollback: {
+                boolean: true;
+                description: string;
+            };
+            scope: {
+                array: true;
+                string: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-package-rollback": {
+        options: {
+            dry: {
+                boolean: true;
+                description: string;
+            };
+            registry: {
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            tag: {
+                string: true;
+                description: string;
+                required: true;
+            };
+            purgeCache: {
+                boolean: true;
+                description: string;
+                defaultDescription: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-package-publish": {
+        options: {
+            branch: {
+                string: true;
+                description: string;
+                defaultDescription: string;
+            };
+            build: {
+                string: true;
+                description: string;
+                defaultDescription: string;
+            };
+            dry: {
+                boolean: true;
+                description: string;
+            };
+            force: {
+                boolean: true;
+                description: string;
+            };
+            registry: {
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            trackHistory: {
+                boolean: true;
+                description: string;
+                defaultDescription: string;
+                hidden: true;
+            };
+            tag: {
+                string: true;
+                description: string;
+            };
+            uploadSourcemaps: {
+                boolean: true;
+                description: string;
+                defaultDescription: string;
+            };
+            purgeCache: {
+                boolean: true;
+                description: string;
+                defaultDescription: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-package-clean": {
+        options: {
+            all: {
+                boolean: true;
+                description: string;
+                defaultDescription: string;
+            };
+            branch: {
+                string: true;
+                description: string;
+                defaultDescription: string;
+            };
+            count: {
+                number: true;
+                description: string;
+                defaultDescription: string;
+            };
+            dry: {
+                boolean: true;
+                description: string;
+            };
+            registry: {
+                string: true;
+                hidden: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-list": {
+        allowRunFromGlobal: true;
+        description: string;
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            all: {
+                boolean: true;
+                description: string;
+            };
+            ignore: {
+                array: true;
+                string: true;
+                description: string;
+            };
+            limit: {
+                number: true;
+                description: string;
+            };
+            packageNames: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+            registry: {
+                string: true;
+                hidden: true;
+            };
+            tagged: {
+                boolean: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-generate-metadata": {
+        allowRunFromGlobal: true;
+        description: string;
+        options: {
+            output: {
+                description: string;
+                string: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    "mfe-check": {
+        allowRunFromGlobal: true;
+        description: string;
+        options: {
+            metadata: {
+                description: string;
+                string: true;
+                demandOption: true;
+                requiresArg: true;
+            };
+            hostPackageJson: {
+                description: string;
+                array: true;
+                string: true;
+                demandOption: true;
+                requiresArg: true;
+            };
+            json: {
+                description: string;
+                boolean: true;
+                default: boolean;
+            };
+        };
+    } & CommandRegistryEntry;
+    lint: {
+        description: string;
+        greedy: true;
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            fix: {
+                boolean: true;
+                description: string;
+            };
+            scope: {
+                array: true;
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            ignore: {
+                array: true;
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            parallel: {
+                boolean: true;
+                hidden: true;
+                description: string;
+            };
+            paths: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    "kendo-ui-license": {
+        allowRunFromGlobal: true;
+        description: string;
+    } & CommandRegistryEntry;
+    install: {
+        allowRunFromGlobal: true;
+        description: string;
+        options: {
+            fix: {
+                boolean: true;
+                description: string;
+                hidden: true;
+            };
+            quiet: {
+                boolean: true;
+                description: string;
+                hidden: true;
+            };
+            token: {
+                boolean: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    init: {
+        description: string;
+        allowRunFromGlobal: true;
+        options: {
+            output: {
+                string: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+    eslint: {
+        options: {
+            _: {
+                description: string;
+                array: true;
+                string: true;
+            };
+            fix: {
+                boolean: true;
+                hidden: true;
+            };
+            paths: {
+                array: true;
+                string: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    "convert-eslint-config": {
+        allowRunFromGlobal: true;
+        description: string;
+    } & CommandRegistryEntry;
+    clean: {
+        allowRunFromGlobal: true;
+        description: string;
+    } & CommandRegistryEntry;
+    "bundle-package": {
+        options: {
+            codeCoverage: {
+                boolean: true;
+                hidden: true;
+            };
+            config: {
+                string: true;
+                hidden: true;
+            };
+            exposedDependencies: {
+                boolean: true;
+                hidden: true;
+            };
+            stat: {
+                boolean: true;
+                hidden: true;
+            };
+            useWatchConfig: {
+                boolean: true;
+                hidden: true;
+            };
+            watch: {
+                boolean: true;
+                hidden: true;
+            };
+        };
+    } & CommandRegistryEntry;
+    build: {
+        description: string;
+        greedy: true;
+        options: {
+            cdnPath: {
+                string: true;
+                description: string;
+            };
+            codeCoverage: {
+                boolean: true;
+                description: string;
+            };
+            config: {
+                string: true;
+                hidden: true;
+                description: string;
+            };
+            ignore: {
+                array: true;
+                string: true;
+                description: string;
+            };
+            scope: {
+                array: true;
+                string: true;
+                description: string;
+            };
+            stat: {
+                boolean: true;
+                description: string;
+            };
+            useTsc: {
+                boolean: true;
+                description: string;
+            };
+        };
+    } & CommandRegistryEntry;
+};
+//# sourceMappingURL=command-registry.d.ts.map

package/dist/cli/commands/registry/command-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-registry.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/registry/command-registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AA2B1D,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACtD,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CACzC;AAiCD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCyB,CAAC"}

package/dist/cli/commands/registry/command-registry.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "commandRegistry", {
+    enumerable: true,
+    get: function() {
+        return commandRegistry;
+    }
+});
+const _utils = require("../../../utils");
+const _build = require("./build");
+const _bundlepackage = require("./bundle-package");
+const _clean = require("./clean");
+const _converteslintconfig = require("./convert-eslint-config");
+const _eslint = require("./eslint");
+const _init = require("./init");
+const _install = require("./install");
+const _kendouilicense = require("./kendo-ui-license");
+const _lint = require("./lint");
+const _mfecheck = require("./mfe-check");
+const _mfegeneratemetadata = require("./mfe-generate-metadata");
+const _mfelist = require("./mfe-list");
+const _mfepackageclean = require("./mfe-package-clean");
+const _mfepackagepublish = require("./mfe-package-publish");
+const _mfepackagerollback = require("./mfe-package-rollback");
+const _mfepublish = require("./mfe-publish");
+const _mfepurgecache = require("./mfe-purge-cache");
+const _preparepackage = require("./prepare-package");
+const _review = require("./review");
+const _start = require("./start");
+const _stylelint = require("./stylelint");
+const _stylescheck = require("./styles-check");
+const _task = require("./task");
+const _testcommand = require("./test-command");
+const _uploadsourcemaps = require("./upload-sourcemaps");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function toPascalCase(name) {
+    return name.split('-').map((part)=>part[0].toUpperCase() + part.slice(1)).join('');
+}
+function makeEntry(key, entry, options = {}) {
+    const { path = key, className = toPascalCase(path) } = options;
+    return {
+        [key]: {
+            ...entry,
+            load: ()=>Promise.resolve(`../${path}`).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p))).then((m)=>m[className])
+        }
+    };
+}
+const commandRegistry = {
+    ...makeEntry(_utils.CommandName.build, _build.entry),
+    ...makeEntry(_utils.CommandName['bundle-package'], _bundlepackage.entry),
+    ...makeEntry(_utils.CommandName.clean, _clean.entry),
+    ...makeEntry(_utils.CommandName['convert-eslint-config'], _converteslintconfig.entry),
+    ...makeEntry(_utils.CommandName.eslint, _eslint.entry, {
+        className: 'ESLintCommand'
+    }),
+    ...makeEntry(_utils.CommandName.init, _init.entry),
+    ...makeEntry(_utils.CommandName.install, _install.entry),
+    ...makeEntry(_utils.CommandName['kendo-ui-license'], _kendouilicense.entry, {
+        className: 'KendoUILicense'
+    }),
+    ...makeEntry(_utils.CommandName.lint, _lint.entry),
+    ...makeEntry(_utils.CommandName['mfe-check'], _mfecheck.entry),
+    ...makeEntry(_utils.CommandName['mfe-generate-metadata'], _mfegeneratemetadata.entry),
+    ...makeEntry(_utils.CommandName['mfe-list'], _mfelist.entry, {
+        className: 'MFEList'
+    }),
+    ...makeEntry(_utils.CommandName['mfe-package-clean'], _mfepackageclean.entry, {
+        className: 'MFEPackageClean'
+    }),
+    ...makeEntry(_utils.CommandName['mfe-package-publish'], _mfepackagepublish.entry, {
+        className: 'MFEPackagePublish'
+    }),
+    ...makeEntry(_utils.CommandName['mfe-package-rollback'], _mfepackagerollback.entry, {
+        className: 'MFEPackageRollback'
+    }),
+    ...makeEntry(_utils.CommandName['mfe-publish'], _mfepublish.entry, {
+        className: 'MFEPublish'
+    }),
+    ...makeEntry(_utils.CommandName['mfe-purge-cache'], _mfepurgecache.entry, {
+        className: 'MFEPurgeCache'
+    }),
+    ...makeEntry(_utils.CommandName['prepare-package'], _preparepackage.entry),
+    ...makeEntry(_utils.CommandName.review, _review.entry),
+    ...makeEntry(_utils.CommandName.start, _start.entry),
+    ...makeEntry(_utils.CommandName.stylelint, _stylelint.entry),
+    ...makeEntry(_utils.CommandName['styles-check'], _stylescheck.entry),
+    ...makeEntry(_utils.CommandName.task, _task.entry, {
+        path: 'run-task'
+    }),
+    ...makeEntry(_utils.CommandName.test, _testcommand.entry, {
+        className: 'Tests'
+    }),
+    ...makeEntry(_utils.CommandName['upload-sourcemaps'], _uploadsourcemaps.entry)
+};
+
+//# sourceMappingURL=command-registry.js.map

package/dist/cli/commands/registry/command-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/commands/registry/command-registry.ts"],"sourcesContent":["import { CommandName } from '../../../utils';\nimport { Command, CommandEntry, Newable } from '../types';\nimport { entry as build } from './build';\nimport { entry as bundlePackage } from './bundle-package';\nimport { entry as clean } from './clean';\nimport { entry as convertEslintConfig } from './convert-eslint-config';\nimport { entry as eslint } from './eslint';\nimport { entry as init } from './init';\nimport { entry as install } from './install';\nimport { entry as kendoUiLicense } from './kendo-ui-license';\nimport { entry as lint } from './lint';\nimport { entry as mfeCheck } from './mfe-check';\nimport { entry as mfeGenerateMetadata } from './mfe-generate-metadata';\nimport { entry as mfeList } from './mfe-list';\nimport { entry as mfePackageClean } from './mfe-package-clean';\nimport { entry as mfePackagePublish } from './mfe-package-publish';\nimport { entry as mfePackageRollback } from './mfe-package-rollback';\nimport { entry as mfePublish } from './mfe-publish';\nimport { entry as mfePurgeCache } from './mfe-purge-cache';\nimport { entry as preparePackage } from './prepare-package';\nimport { entry as review } from './review';\nimport { entry as start } from './start';\nimport { entry as stylelint } from './stylelint';\nimport { entry as stylesCheck } from './styles-check';\nimport { entry as task } from './task';\nimport { entry as test } from './test-command';\nimport { entry as uploadSourcemaps } from './upload-sourcemaps';\n\nexport interface CommandRegistryEntry extends CommandEntry {\n    load: () => Promise<Newable<Command>>;\n}\n\nfunction toPascalCase(name: string): string {\n    return name\n        .split('-')\n        .map(part => part[0].toUpperCase() + part.slice(1))\n        .join('');\n}\n\ninterface MakeEntryOptions {\n    path?: string;\n    className?: string;\n}\n\nfunction makeEntry<K extends CommandName, T extends CommandEntry>(\n    key: K,\n    entry: T,\n    options: MakeEntryOptions = {}\n) {\n    const { path = key, className = toPascalCase(path) } = options;\n    return {\n        [key]: {\n            ...entry,\n            load: () => import(`../${path}`).then(m => m[className]),\n        },\n    } as { [k in K]: T & CommandRegistryEntry };\n}\n\n/*\n * Each makeEntry call returns a single-key object. Spreading them preserves the\n * per-command type information, as opposed to widening each value to the union\n * return type.\n */\nexport const commandRegistry = {\n    ...makeEntry(CommandName.build, build),\n    ...makeEntry(CommandName['bundle-package'], bundlePackage),\n    ...makeEntry(CommandName.clean, clean),\n    ...makeEntry(CommandName['convert-eslint-config'], convertEslintConfig),\n    ...makeEntry(CommandName.eslint, eslint, { className: 'ESLintCommand' }),\n    ...makeEntry(CommandName.init, init),\n    ...makeEntry(CommandName.install, install),\n    ...makeEntry(CommandName['kendo-ui-license'], kendoUiLicense, { className: 'KendoUILicense' }),\n    ...makeEntry(CommandName.lint, lint),\n    ...makeEntry(CommandName['mfe-check'], mfeCheck),\n    ...makeEntry(CommandName['mfe-generate-metadata'], mfeGenerateMetadata),\n    ...makeEntry(CommandName['mfe-list'], mfeList, { className: 'MFEList' }),\n    ...makeEntry(CommandName['mfe-package-clean'], mfePackageClean, {\n        className: 'MFEPackageClean',\n    }),\n    ...makeEntry(CommandName['mfe-package-publish'], mfePackagePublish, {\n        className: 'MFEPackagePublish',\n    }),\n    ...makeEntry(CommandName['mfe-package-rollback'], mfePackageRollback, {\n        className: 'MFEPackageRollback',\n    }),\n    ...makeEntry(CommandName['mfe-publish'], mfePublish, { className: 'MFEPublish' }),\n    ...makeEntry(CommandName['mfe-purge-cache'], mfePurgeCache, {\n        className: 'MFEPurgeCache',\n    }),\n    ...makeEntry(CommandName['prepare-package'], preparePackage),\n    ...makeEntry(CommandName.review, review),\n    ...makeEntry(CommandName.start, start),\n    ...makeEntry(CommandName.stylelint, stylelint),\n    ...makeEntry(CommandName['styles-check'], stylesCheck),\n    ...makeEntry(CommandName.task, task, { path: 'run-task' }),\n    ...makeEntry(CommandName.test, test, { className: 'Tests' }),\n    ...makeEntry(CommandName['upload-sourcemaps'], uploadSourcemaps),\n} satisfies Record<CommandName, CommandRegistryEntry>;\n"],"names":["commandRegistry","toPascalCase","name","split","map","part","toUpperCase","slice","join","makeEntry","key","entry","options","path","className","load","then","m","CommandName","build","bundlePackage","clean","convertEslintConfig","eslint","init","install","kendoUiLicense","lint","mfeCheck","mfeGenerateMetadata","mfeList","mfePackageClean","mfePackagePublish","mfePackageRollback","mfePublish","mfePurgeCache","preparePackage","review","start","stylelint","stylesCheck","task","test","uploadSourcemaps"],"mappings":"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"}

package/dist/cli/commands/registry/convert-eslint-config.d.ts

@@ -0,0 +1,5 @@
+export declare const entry: {
+    allowRunFromGlobal: true;
+    description: string;
+};
+//# sourceMappingURL=convert-eslint-config.d.ts.map

package/dist/cli/commands/registry/convert-eslint-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-eslint-config.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/registry/convert-eslint-config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;CAGO,CAAC"}

package/dist/cli/commands/registry/convert-eslint-config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "entry", {
+    enumerable: true,
+    get: function() {
+        return entry;
+    }
+});
+const _defineentry = require("./define-entry");
+const entry = (0, _defineentry.defineEntry)({
+    allowRunFromGlobal: true,
+    description: 'Convert v8.x eslintrc.json to v9.x flat config'
+});
+
+//# sourceMappingURL=convert-eslint-config.js.map

package/dist/cli/commands/registry/convert-eslint-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/commands/registry/convert-eslint-config.ts"],"sourcesContent":["import type { CommandEntry } from '../types';\nimport { defineEntry } from './define-entry';\n\nexport const entry = defineEntry({\n    allowRunFromGlobal: true,\n    description: 'Convert v8.x eslintrc.json to v9.x flat config',\n} satisfies CommandEntry);\n"],"names":["entry","defineEntry","allowRunFromGlobal","description"],"mappings":";;;;+BAGaA;;;eAAAA;;;6BAFe;AAErB,MAAMA,QAAQC,IAAAA,wBAAW,EAAC;IAC7BC,oBAAoB;IACpBC,aAAa;AACjB"}