rolldown 1.0.0-beta.1-commit.7c52c94 → 1.0.0-beta.2-commit.f069c5d

package/dist/shared/{src-lBcHSsjm.cjs → src-BRzD1T3r.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 const require_chunk = require('./chunk-qZFfknuJ.cjs');
-const require_binding = require('./binding-fhgdIkpS.cjs');
+const require_binding = require('./binding-orkvONpS.cjs');
 const node_path = require_chunk.__toESM(require("node:path"));
 const node_buffer = require_chunk.__toESM(require("node:buffer"));
 const node_worker_threads = require_chunk.__toESM(require("node:worker_threads"));
@@ -1753,7 +1753,7 @@ function bindingifySourcemapIgnoreList(sourcemapIgnoreList) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-K26VP6CL.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-K26VP6CL.js
 function u$1(t$1, n, a) {
 	let o = (r) => t$1(r, ...n);
 	return a === void 0 ? o : Object.assign(o, {
@@ -1763,7 +1763,7 @@ function u$1(t$1, n, a) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-RAAYCPUM.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-RAAYCPUM.js
 function u(r, n, a) {
 	let o = r.length - n.length;
 	if (o === 0) return r(...n);
@@ -1772,7 +1772,7 @@ function u(r, n, a) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-NMJS7ULY.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-NMJS7ULY.js
 function t(...n) {
 	return u(Object.keys, n);
 }
@@ -2303,13 +2303,19 @@ const ChunkFileNamesSchema = valibot.union([valibot.string(), valibot.pipe(valib
 const GlobalsFunctionSchema = valibot.pipe(valibot.function(), valibot.args(valibot.tuple([valibot.string()])), valibot.returns(valibot.string()));
 const AdvancedChunksSchema = valibot.strictObject({
 	minSize: valibot.optional(valibot.number()),
+	maxSize: valibot.optional(valibot.number()),
+	minModuleSize: valibot.optional(valibot.number()),
+	maxModuleSize: valibot.optional(valibot.number()),
 	minShareCount: valibot.optional(valibot.number()),
 	groups: valibot.optional(valibot.array(valibot.strictObject({
 		name: valibot.string(),
 		test: valibot.optional(valibot.union([valibot.string(), valibot.instance(RegExp)])),
 		priority: valibot.optional(valibot.number()),
 		minSize: valibot.optional(valibot.number()),
-		minShareCount: valibot.optional(valibot.number())
+		minShareCount: valibot.optional(valibot.number()),
+		maxSize: valibot.optional(valibot.number()),
+		minModuleSize: valibot.optional(valibot.number()),
+		maxModuleSize: valibot.optional(valibot.number())
 	})))
 });
 const OutputOptionsSchema = valibot.strictObject({
@@ -2616,7 +2622,7 @@ const watch = (input) => {
 
 //#endregion
 //#region package.json
-var version = "1.0.0-beta.1-commit.7c52c94";
+var version = "1.0.0-beta.2-commit.f069c5d";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion

package/dist/shared/{src-CPCP99Z9.mjs → src-Cmr3pg11.mjs}

@@ -1,4 +1,4 @@
-import { augmentCodeLocation, colors, error, import_binding, logCycleLoading, logInputHookInOutputPlugin, logInvalidLogPosition, logMinifyWarning, logMultiplyNotifyOption, logPluginError } from "./binding-Bl7VQy7c.mjs";
+import { augmentCodeLocation, colors, error, import_binding, logCycleLoading, logInputHookInOutputPlugin, logInvalidLogPosition, logMinifyWarning, logMultiplyNotifyOption, logPluginError } from "./binding-l7VLSKnB.mjs";
 import path from "node:path";
 import { Buffer } from "node:buffer";
 import { Worker } from "node:worker_threads";
@@ -1751,7 +1751,7 @@ function bindingifySourcemapIgnoreList(sourcemapIgnoreList) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-K26VP6CL.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-K26VP6CL.js
 function u$1(t$1, n, a) {
 	let o = (r) => t$1(r, ...n);
 	return a === void 0 ? o : Object.assign(o, {
@@ -1761,7 +1761,7 @@ function u$1(t$1, n, a) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-RAAYCPUM.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-RAAYCPUM.js
 function u(r, n, a) {
 	let o = r.length - n.length;
 	if (o === 0) return r(...n);
@@ -1770,7 +1770,7 @@ function u(r, n, a) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.16.0/node_modules/remeda/dist/chunk-NMJS7ULY.js
+//#region ../../node_modules/.pnpm/remeda@2.19.1/node_modules/remeda/dist/chunk-NMJS7ULY.js
 function t(...n) {
 	return u(Object.keys, n);
 }
@@ -2301,13 +2301,19 @@ const ChunkFileNamesSchema = v.union([v.string(), v.pipe(v.function(), v.args(v.
 const GlobalsFunctionSchema = v.pipe(v.function(), v.args(v.tuple([v.string()])), v.returns(v.string()));
 const AdvancedChunksSchema = v.strictObject({
 	minSize: v.optional(v.number()),
+	maxSize: v.optional(v.number()),
+	minModuleSize: v.optional(v.number()),
+	maxModuleSize: v.optional(v.number()),
 	minShareCount: v.optional(v.number()),
 	groups: v.optional(v.array(v.strictObject({
 		name: v.string(),
 		test: v.optional(v.union([v.string(), v.instance(RegExp)])),
 		priority: v.optional(v.number()),
 		minSize: v.optional(v.number()),
-		minShareCount: v.optional(v.number())
+		minShareCount: v.optional(v.number()),
+		maxSize: v.optional(v.number()),
+		minModuleSize: v.optional(v.number()),
+		maxModuleSize: v.optional(v.number())
 	})))
 });
 const OutputOptionsSchema = v.strictObject({
@@ -2614,7 +2620,7 @@ const watch = (input) => {
 
 //#endregion
 //#region package.json
-var version = "1.0.0-beta.1-commit.7c52c94";
+var version = "1.0.0-beta.2-commit.f069c5d";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion

package/dist/types/api/build.js

@@ -0,0 +1,22 @@
+import { rolldown } from './rolldown';
+async function build(options) {
+    if (Array.isArray(options)) {
+        return Promise.all(options.map((opts) => build(opts)));
+    }
+    else {
+        const { output, write = true, ...inputOptions } = options;
+        const build = await rolldown(inputOptions);
+        try {
+            if (write) {
+                return await build.write(output);
+            }
+            else {
+                return await build.generate(output);
+            }
+        }
+        finally {
+            await build.close();
+        }
+    }
+}
+export { build };

package/dist/types/api/experimental.js

@@ -0,0 +1,13 @@
+import { createBundler } from '../utils/create-bundler';
+import { handleOutputErrors } from '../utils/transform-to-rollup-output';
+/**
+ * This is an experimental API. It's behavior may change in the future.
+ *
+ * Calling this API will only execute the scan stage of rolldown.
+ */
+export const experimental_scan = async (input) => {
+    const { bundler, stopWorkers } = await createBundler(input, {});
+    const output = await bundler.scan();
+    handleOutputErrors(output);
+    await stopWorkers?.();
+};

package/dist/types/api/rolldown/index.js

@@ -0,0 +1,7 @@
+import { PluginDriver } from '../../plugin/plugin-driver';
+import { RolldownBuild } from './rolldown-build';
+// `async` here is intentional to be compatible with `rollup.rollup`.
+export const rolldown = async (input) => {
+    const inputOptions = await PluginDriver.callOptionsHook(input);
+    return new RolldownBuild(inputOptions);
+};

package/dist/types/api/rolldown/rolldown-build.js

@@ -0,0 +1,43 @@
+import { transformToRollupOutput } from '../../utils/transform-to-rollup-output';
+import { createBundler, } from '../../utils/create-bundler';
+// @ts-expect-error TS2540: the polyfill of `asyncDispose`.
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
+export class RolldownBuild {
+    #inputOptions;
+    #bundler;
+    constructor(inputOptions) {
+        // TODO: Check if `inputOptions.output` is set. If so, throw an warning that it is ignored.
+        this.#inputOptions = inputOptions;
+    }
+    get closed() {
+        // If the bundler has not yet been created, it is not closed.
+        return this.#bundler ? this.#bundler.bundler.closed : false;
+    }
+    // Create bundler for each `bundle.write/generate`
+    async #getBundlerWithStopWorker(outputOptions) {
+        if (this.#bundler) {
+            this.#bundler.stopWorkers?.();
+        }
+        return (this.#bundler = await createBundler(this.#inputOptions, outputOptions));
+    }
+    async generate(outputOptions = {}) {
+        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
+        const output = await bundler.generate();
+        return transformToRollupOutput(output);
+    }
+    async write(outputOptions = {}) {
+        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
+        const output = await bundler.write();
+        return transformToRollupOutput(output);
+    }
+    async close() {
+        const { bundler, stopWorkers } = await this.#getBundlerWithStopWorker({});
+        await stopWorkers?.();
+        await bundler.close();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+}
+function _assert() {
+}

package/dist/types/api/watch/index.js

@@ -0,0 +1,8 @@
+import { WatcherEmitter } from './watch-emitter';
+import { createWatcher } from './watcher';
+// Compat to `rollup.watch`
+export const watch = (input) => {
+    const emitter = new WatcherEmitter();
+    createWatcher(emitter, input);
+    return emitter;
+};

package/dist/types/api/watch/watch-emitter.js

@@ -0,0 +1,69 @@
+import { normalizeErrors } from '../../utils/error';
+export class WatcherEmitter {
+    listeners = new Map();
+    timer;
+    constructor() {
+        // The rust side already create a thread for watcher, but it isn't at main thread.
+        // So here we need to avoid main process exit util the user call `watcher.close()`.
+        this.timer = setInterval(() => { }, 1e9 /* Low power usage */);
+    }
+    on(event, listener) {
+        const listeners = this.listeners.get(event);
+        if (listeners) {
+            listeners.push(listener);
+        }
+        else {
+            this.listeners.set(event, [listener]);
+        }
+        return this;
+    }
+    async onEvent(event) {
+        const listeners = this.listeners.get(event.eventKind());
+        if (listeners) {
+            switch (event.eventKind()) {
+                case 'close':
+                case 'restart':
+                    for (const listener of listeners) {
+                        await listener();
+                    }
+                    break;
+                case 'event':
+                    for (const listener of listeners) {
+                        const code = event.bundleEventKind();
+                        switch (code) {
+                            case 'BUNDLE_END':
+                                const { duration, output } = event.bundleEndData();
+                                await listener({
+                                    code: 'BUNDLE_END',
+                                    duration,
+                                    output: [output], // rolldown doesn't support arraying configure output
+                                });
+                                break;
+                            case 'ERROR':
+                                const errors = event.errors();
+                                await listener({
+                                    code: 'ERROR',
+                                    error: normalizeErrors(errors),
+                                });
+                                break;
+                            default:
+                                await listener({ code });
+                                break;
+                        }
+                    }
+                    break;
+                case 'change':
+                    for (const listener of listeners) {
+                        const { path, kind } = event.watchChangeData();
+                        await listener(path, { event: kind });
+                    }
+                    break;
+                default:
+                    throw new Error(`Unknown event: ${event}`);
+            }
+        }
+    }
+    async close() {
+        clearInterval(this.timer);
+    }
+}

package/dist/types/api/watch/watcher.js

@@ -0,0 +1,66 @@
+import { BindingWatcher } from '../../binding';
+import { LOG_LEVEL_WARN } from '../../log/logging';
+import { logMultiplyNotifyOption } from '../../log/logs';
+import { PluginDriver } from '../../plugin/plugin-driver';
+import { createBundlerOptions, } from '../../utils/create-bundler-option';
+import { arraify } from '../../utils/misc';
+export class Watcher {
+    closed;
+    inner;
+    emitter;
+    stopWorkers;
+    constructor(emitter, inner, stopWorkers) {
+        this.closed = false;
+        this.inner = inner;
+        this.emitter = emitter;
+        const originClose = emitter.close.bind(emitter);
+        emitter.close = async () => {
+            await this.close();
+            originClose();
+        };
+        this.stopWorkers = stopWorkers;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const stop of this.stopWorkers) {
+            await stop?.();
+        }
+        await this.inner.close();
+    }
+    start() {
+        // run first build after listener is attached
+        process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
+    }
+}
+export async function createWatcher(emitter, input) {
+    const options = arraify(input);
+    const bundlerOptions = await Promise.all(options
+        .map((option) => arraify(option.output || {}).map(async (output) => {
+        const inputOptions = await PluginDriver.callOptionsHook(option);
+        return createBundlerOptions(inputOptions, output);
+    }))
+        .flat());
+    const notifyOptions = getValidNotifyOption(bundlerOptions);
+    const bindingWatcher = new BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
+    const watcher = new Watcher(emitter, bindingWatcher, bundlerOptions.map((option) => option.stopWorkers));
+    watcher.start();
+}
+function getValidNotifyOption(bundlerOptions) {
+    let result;
+    for (const option of bundlerOptions) {
+        if (option.inputOptions.watch) {
+            const notifyOption = option.inputOptions.watch.notify;
+            if (notifyOption) {
+                if (result) {
+                    option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
+                    return result;
+                }
+                else {
+                    result = notifyOption;
+                }
+            }
+        }
+    }
+}

package/dist/types/binding.d.ts

@@ -157,6 +157,7 @@ export declare class MagicString {
   getUtf16ByteOffset(offset: number): number
   length(): number
   toString(): string
+  hasChanged(): boolean
   append(input: string): this
   appendLeft(index: number, input: string): this
   appendRight(index: number, input: string): this
@@ -166,6 +167,20 @@ export declare class MagicString {
   prependRight(index: number, input: string): this
   relocate(start: number, end: number, to: number): this
   remove(start: number, end: number): this
+  generateMap(options?: Partial<GenerateDecodedMapOptions>): {
+    toString: () => string;
+    toUrl: () => string;
+    toMap: () => {
+      file?: string
+      mappings: string
+      names: Array<string>
+      sourceRoot?: string
+      sources: Array<string>
+      sourcesContent?: Array<string>
+      version: number
+      x_google_ignoreList?: Array<number>
+    }
+  }
 }
 
 export declare class ParallelJsPluginRegistry {
@@ -216,6 +231,9 @@ export interface BindingAdvancedChunksOptions {
   minSize?: number
   minShareCount?: number
   groups?: Array<BindingMatchGroup>
+  maxSize?: number
+  minModuleSize?: number
+  maxModuleSize?: number
 }
 
 export interface BindingAliasPluginAlias {
@@ -439,6 +457,9 @@ export interface BindingMatchGroup {
   priority?: number
   minSize?: number
   minShareCount?: number
+  minModuleSize?: number
+  maxModuleSize?: number
+  maxSize?: number
 }
 
 export interface BindingModuleFederationPluginOption {
@@ -690,6 +711,12 @@ export interface CompilerAssumptions {
   setPublicClassFields?: boolean
 }
 
+export interface DynamicImport {
+  start: number
+  end: number
+  moduleRequest: Span
+}
+
 export interface EcmaScriptModule {
   /**
    * Has ESM syntax.
@@ -699,10 +726,12 @@ export interface EcmaScriptModule {
    * Dynamic imports `import('foo')` are ignored since they can be used in non-ESM files.
    */
   hasModuleSyntax: boolean
-  /** Import Statements. */
+  /** Import statements. */
   staticImports: Array<StaticImport>
-  /** Export Statements. */
+  /** Export statements. */
   staticExports: Array<StaticExport>
+  /** Dynamic import expressions. */
+  dynamicImports: Array<DynamicImport>
   /** Span positions` of `import.meta` */
   importMetas: Array<Span>
 }
@@ -770,6 +799,15 @@ export interface ExtensionAliasItem {
   replacements: Array<string>
 }
 
+export interface GenerateDecodedMapOptions {
+  /** The filename of the file containing the original source. */
+  source?: string
+  /** Whether to include the original content in the map's `sourcesContent` array. */
+  includeContent: boolean
+  /** Whether the mapping should be high-resolution. */
+  hires: boolean | 'boundary'
+}
+
 export type HelperMode = /**
  * Runtime mode (default): Helper functions are imported from a runtime package.
  *

package/dist/types/builtin-plugin/alias-plugin.js

@@ -0,0 +1,4 @@
+import { BuiltinPlugin } from './constructors';
+export function aliasPlugin(config) {
+    return new BuiltinPlugin('builtin:alias', config);
+}

package/dist/types/builtin-plugin/constructors.d.ts

@@ -1,8 +1,8 @@
 import { type BindingBuiltinPluginName, BindingGlobImportPluginConfig, BindingManifestPluginConfig, BindingModulePreloadPolyfillPluginConfig, BindingJsonPluginConfig, BindingBuildImportAnalysisPluginConfig, type BindingViteResolvePluginConfig, BindingModuleFederationPluginOption, BindingRemote } from '../binding';
 export declare class BuiltinPlugin {
     name: BindingBuiltinPluginName;
-    _options?: unknown;
-    constructor(name: BindingBuiltinPluginName, _options?: unknown);
+    _options?: unknown | undefined;
+    constructor(name: BindingBuiltinPluginName, _options?: unknown | undefined);
 }
 export declare function modulePreloadPolyfillPlugin(config?: BindingModulePreloadPolyfillPluginConfig): BuiltinPlugin;
 export declare function dynamicImportVarsPlugin(): BuiltinPlugin;

package/dist/types/builtin-plugin/constructors.js

@@ -0,0 +1,68 @@
+import { makeBuiltinPluginCallable } from './utils';
+export class BuiltinPlugin {
+    name;
+    _options;
+    constructor(name, 
+    // NOTE: has `_` to avoid conflict with `options` hook
+    _options) {
+        this.name = name;
+        this._options = _options;
+        this.name = name;
+        this._options = _options;
+    }
+}
+export function modulePreloadPolyfillPlugin(config) {
+    return new BuiltinPlugin('builtin:module-preload-polyfill', config);
+}
+export function dynamicImportVarsPlugin() {
+    return new BuiltinPlugin('builtin:dynamic-import-vars');
+}
+export function importGlobPlugin(config) {
+    return new BuiltinPlugin('builtin:import-glob', config);
+}
+export function manifestPlugin(config) {
+    return new BuiltinPlugin('builtin:manifest', config);
+}
+export function wasmHelperPlugin() {
+    return new BuiltinPlugin('builtin:wasm-helper');
+}
+export function wasmFallbackPlugin() {
+    return new BuiltinPlugin('builtin:wasm-fallback');
+}
+export function loadFallbackPlugin() {
+    return new BuiltinPlugin('builtin:load-fallback');
+}
+export function jsonPlugin(config) {
+    return new BuiltinPlugin('builtin:json', config);
+}
+export function buildImportAnalysisPlugin(config) {
+    return new BuiltinPlugin('builtin:build-import-analysis', config);
+}
+export function viteResolvePlugin(config) {
+    const builtinPlugin = new BuiltinPlugin('builtin:vite-resolve', {
+        ...config,
+        runtime: process.versions.deno
+            ? 'deno'
+            : process.versions.bun
+                ? 'bun'
+                : 'node',
+    });
+    return makeBuiltinPluginCallable(builtinPlugin);
+}
+export function moduleFederationPlugin(config) {
+    return new BuiltinPlugin('builtin:module-federation', {
+        ...config,
+        remotes: config.remotes &&
+            Object.entries(config.remotes).map(([name, remote]) => {
+                if (typeof remote === 'string') {
+                    const [entryGlobalName] = remote.split('@');
+                    const entry = remote.replace(entryGlobalName + '@', '');
+                    return { entry, name };
+                }
+                return {
+                    ...remote,
+                    name: remote.name ?? name,
+                };
+            }),
+    });
+}

package/dist/types/builtin-plugin/replace-plugin.js

@@ -0,0 +1,29 @@
+import { BuiltinPlugin } from './constructors';
+/**
+ * Replaces targeted strings in files while bundling.
+ *
+ * @example
+ * // Basic usage
+ * ```js
+ * replacePlugin({
+ *   'process.env.NODE_ENV': JSON.stringify('production'),
+ *    __buildDate__: () => JSON.stringify(new Date()),
+ *    __buildVersion: 15
+ * })
+ * ```
+ * @example
+ * // With options
+ * ```js
+ * replacePlugin({
+ *   'process.env.NODE_ENV': JSON.stringify('production'),
+ *   __buildDate__: () => JSON.stringify(new Date()),
+ *   __buildVersion: 15
+ * }, {
+ *   preventAssignment: false,
+ * })
+ * ```
+ *
+ */
+export function replacePlugin(values = {}, options = {}) {
+    return new BuiltinPlugin('builtin:replace', { ...options, values });
+}

package/dist/types/builtin-plugin/transform-plugin.js

@@ -0,0 +1,16 @@
+import { BuiltinPlugin } from './constructors';
+import { normalizedStringOrRegex } from '../utils/normalize-string-or-regex';
+function normalizeEcmaTransformPluginConfig(config) {
+    if (!config) {
+        return undefined;
+    }
+    let normalizedConfig = {
+        ...config,
+        exclude: normalizedStringOrRegex(config.exclude),
+        include: normalizedStringOrRegex(config.include),
+    };
+    return normalizedConfig;
+}
+export function transformPlugin(config) {
+    return new BuiltinPlugin('builtin:transform', normalizeEcmaTransformPluginConfig(config));
+}

package/dist/types/builtin-plugin/utils.js

@@ -0,0 +1,19 @@
+import { BindingCallableBuiltinPlugin } from '../binding';
+export function makeBuiltinPluginCallable(plugin) {
+    let callablePlugin = new BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+    const wrappedPlugin = plugin;
+    for (const key in callablePlugin) {
+        // @ts-expect-error
+        wrappedPlugin[key] = function (...args) {
+            // @ts-expect-error
+            return callablePlugin[key](...args);
+        };
+    }
+    return wrappedPlugin;
+}
+export function bindingifyBuiltInPlugin(plugin) {
+    return {
+        __name: plugin.name,
+        options: plugin._options,
+    };
+}

package/dist/types/cli/arguments/alias.js

@@ -0,0 +1,63 @@
+export const alias = {
+    config: {
+        abbreviation: 'c',
+        hint: 'filename',
+    },
+    help: {
+        abbreviation: 'h',
+    },
+    version: {
+        abbreviation: 'v',
+    },
+    watch: {
+        abbreviation: 'w',
+    },
+    dir: {
+        abbreviation: 'd',
+    },
+    file: {
+        abbreviation: 'o',
+    },
+    external: {
+        abbreviation: 'e',
+    },
+    format: {
+        abbreviation: 'f',
+    },
+    name: {
+        abbreviation: 'n',
+    },
+    globals: {
+        abbreviation: 'g',
+    },
+    sourcemap: {
+        abbreviation: 's',
+        default: true,
+    },
+    minify: {
+        abbreviation: 'm',
+    },
+    platform: {
+        abbreviation: 'p',
+    },
+    assetFileNames: {
+        hint: 'name',
+    },
+    chunkFileNames: {
+        hint: 'name',
+    },
+    entryFileNames: {
+        hint: 'name',
+    },
+    externalLiveBindings: {
+        default: true,
+        reverse: true,
+    },
+    treeshake: {
+        default: true,
+        reverse: true,
+    },
+    moduleTypes: {
+        hint: 'types',
+    },
+};