0.2.0 - Mid migration

web/node_modules/rollup/dist/rollup.d.ts

@@ -0,0 +1,656 @@
+import * as ESTree from 'estree';
+import { EventEmitter } from 'events';
+
+export const VERSION: string;
+
+export interface RollupError extends RollupLogProps {
+	parserError?: Error;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+export interface RollupWarning extends RollupLogProps {
+	chunkName?: string;
+	cycle?: string[];
+	exporter?: string;
+	exportName?: string;
+	guess?: string;
+	importer?: string;
+	missing?: string;
+	modules?: string[];
+	names?: string[];
+	reexporter?: string;
+	source?: string;
+	sources?: string[];
+}
+
+export interface RollupLogProps {
+	code?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	name?: string;
+	plugin?: string;
+	pluginCode?: string;
+	pos?: number;
+	url?: string;
+}
+
+export type SourceMapSegment =
+	| [number]
+	| [number, number, number, number]
+	| [number, number, number, number, number];
+
+export interface ExistingDecodedSourceMap {
+	file?: string;
+	mappings: SourceMapSegment[][];
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+}
+
+export interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+}
+
+export type DecodedSourceMapOrMissing =
+	| {
+			mappings?: never;
+			missing: true;
+			plugin: string;
+	  }
+	| ExistingDecodedSourceMap;
+
+export interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent: string[];
+	version: number;
+	toString(): string;
+	toUrl(): string;
+}
+
+export type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
+
+export interface SourceDescription {
+	ast?: ESTree.Program;
+	code: string;
+	map?: SourceMapInput;
+	moduleSideEffects?: boolean | null;
+	syntheticNamedExports?: boolean;
+}
+
+export interface TransformSourceDescription extends SourceDescription {
+	dependencies?: string[];
+}
+
+export interface TransformModuleJSON {
+	ast: ESTree.Program;
+	code: string;
+	// note if plugins use new this.cache to opt-out auto transform cache
+	customTransformCache: boolean;
+	moduleSideEffects: boolean | null;
+	originalCode: string;
+	originalSourcemap: ExistingDecodedSourceMap | null;
+	resolvedIds?: ResolvedIdMap;
+	sourcemapChain: DecodedSourceMapOrMissing[];
+	syntheticNamedExports: boolean | null;
+	transformDependencies: string[];
+}
+
+export interface ModuleJSON extends TransformModuleJSON {
+	dependencies: string[];
+	id: string;
+	transformFiles: EmittedFile[] | undefined;
+}
+
+export interface PluginCache {
+	delete(id: string): boolean;
+	get<T = any>(id: string): T;
+	has(id: string): boolean;
+	set<T = any>(id: string, value: T): void;
+}
+
+export interface MinimalPluginContext {
+	meta: PluginContextMeta;
+}
+
+export interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	source?: string | Buffer;
+	type: 'asset';
+}
+
+export interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	name?: string;
+	type: 'chunk';
+}
+
+export type EmittedFile = EmittedAsset | EmittedChunk;
+
+export type EmitAsset = (name: string, source?: string | Buffer) => string;
+
+export type EmitChunk = (id: string, options?: { name?: string }) => string;
+
+export type EmitFile = (emittedFile: EmittedFile) => string;
+
+export interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	/** @deprecated Use `this.emitFile` instead */
+	emitAsset: EmitAsset;
+	/** @deprecated Use `this.emitFile` instead */
+	emitChunk: EmitChunk;
+	emitFile: EmitFile;
+	error: (err: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	/** @deprecated Use `this.getFileName` instead */
+	getAssetFileName: (assetReferenceId: string) => string;
+	/** @deprecated Use `this.getFileName` instead */
+	getChunkFileName: (chunkReferenceId: string) => string;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleInfo: (
+		moduleId: string
+	) => {
+		hasModuleSideEffects: boolean;
+		id: string;
+		importedIds: string[];
+		isEntry: boolean;
+		isExternal: boolean;
+	};
+	/** @deprecated Use `this.resolve` instead */
+	isExternal: IsExternal;
+	moduleIds: IterableIterator<string>;
+	parse: (input: string, options: any) => ESTree.Program;
+	resolve: (
+		source: string,
+		importer: string,
+		options?: { skipSelf: boolean }
+	) => Promise<ResolvedId | null>;
+	/** @deprecated Use `this.resolve` instead */
+	resolveId: (source: string, importer: string) => Promise<string | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Buffer) => void;
+	warn: (warning: RollupWarning | string, pos?: number | { column: number; line: number }) => void;
+	/** @deprecated Use `this.addWatchFile` and the `watchChange` hook instead  */
+	watcher: EventEmitter;
+}
+
+export interface PluginContextMeta {
+	rollupVersion: string;
+}
+
+export interface ResolvedId {
+	external: boolean;
+	id: string;
+	moduleSideEffects: boolean;
+	syntheticNamedExports: boolean;
+}
+
+export interface ResolvedIdMap {
+	[key: string]: ResolvedId;
+}
+
+interface PartialResolvedId {
+	external?: boolean;
+	id: string;
+	moduleSideEffects?: boolean | null;
+	syntheticNamedExports?: boolean;
+}
+
+export type ResolveIdResult = string | false | null | undefined | PartialResolvedId;
+
+export type ResolveIdHook = (
+	this: PluginContext,
+	source: string,
+	importer: string | undefined
+) => Promise<ResolveIdResult> | ResolveIdResult;
+
+export type IsExternal = (
+	source: string,
+	importer: string,
+	isResolved: boolean
+) => boolean | null | undefined;
+
+export type IsPureModule = (id: string) => boolean | null | undefined;
+
+export type HasModuleSideEffects = (id: string, external: boolean) => boolean;
+
+type LoadResult = SourceDescription | string | null | undefined;
+
+export type LoadHook = (this: PluginContext, id: string) => Promise<LoadResult> | LoadResult;
+
+export type TransformResult = string | null | undefined | TransformSourceDescription;
+
+export type TransformHook = (
+	this: PluginContext,
+	code: string,
+	id: string
+) => Promise<TransformResult> | TransformResult;
+
+export type TransformChunkHook = (
+	this: PluginContext,
+	code: string,
+	options: OutputOptions
+) =>
+	| Promise<{ code: string; map?: SourceMapInput } | null | undefined>
+	| { code: string; map?: SourceMapInput }
+	| null
+	| undefined;
+
+export type RenderChunkHook = (
+	this: PluginContext,
+	code: string,
+	chunk: RenderedChunk,
+	options: OutputOptions
+) =>
+	| Promise<{ code: string; map?: SourceMapInput } | null>
+	| { code: string; map?: SourceMapInput }
+	| string
+	| null;
+
+export type ResolveDynamicImportHook = (
+	this: PluginContext,
+	specifier: string | ESTree.Node,
+	importer: string
+) => Promise<ResolveIdResult> | ResolveIdResult;
+
+export type ResolveImportMetaHook = (
+	this: PluginContext,
+	prop: string | null,
+	options: { chunkId: string; format: string; moduleId: string }
+) => string | null | undefined;
+
+export type ResolveAssetUrlHook = (
+	this: PluginContext,
+	options: {
+		assetFileName: string;
+		chunkId: string;
+		format: string;
+		moduleId: string;
+		relativeAssetPath: string;
+	}
+) => string | null | undefined;
+
+export type ResolveFileUrlHook = (
+	this: PluginContext,
+	options: {
+		assetReferenceId: string | null;
+		chunkId: string;
+		chunkReferenceId: string | null;
+		fileName: string;
+		format: string;
+		moduleId: string;
+		referenceId: string;
+		relativePath: string;
+	}
+) => string | null | undefined;
+
+export type AddonHook = string | ((this: PluginContext) => string | Promise<string>);
+
+/**
+ * use this type for plugin annotation
+ * @example
+ * ```ts
+ * interface Options {
+ * ...
+ * }
+ * const myPlugin: PluginImpl<Options> = (options = {}) => { ... }
+ * ```
+ */
+export type PluginImpl<O extends object = object> = (options?: O) => Plugin;
+
+export interface OutputBundle {
+	[fileName: string]: OutputAsset | OutputChunk;
+}
+
+export interface FilePlaceholder {
+	type: 'placeholder';
+}
+
+export interface OutputBundleWithPlaceholders {
+	[fileName: string]: OutputAsset | OutputChunk | FilePlaceholder;
+}
+
+interface OnGenerateOptions extends OutputOptions {
+	bundle: OutputChunk;
+}
+
+interface OnWriteOptions extends OutputOptions {
+	bundle: RollupBuild;
+}
+
+interface OutputPluginHooks {
+	augmentChunkHash: (this: PluginContext, chunk: PreRenderedChunk) => string | void;
+	generateBundle: (
+		this: PluginContext,
+		options: OutputOptions,
+		bundle: OutputBundle,
+		isWrite: boolean
+	) => void | Promise<void>;
+	/** @deprecated Use `generateBundle` instead */
+	ongenerate: (
+		this: PluginContext,
+		options: OnGenerateOptions,
+		chunk: OutputChunk
+	) => void | Promise<void>;
+	/** @deprecated Use `writeBundle` instead */
+	onwrite: (
+		this: PluginContext,
+		options: OnWriteOptions,
+		chunk: OutputChunk
+	) => void | Promise<void>;
+	outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | null | undefined;
+	renderChunk: RenderChunkHook;
+	renderError: (this: PluginContext, err?: Error) => Promise<void> | void;
+	renderStart: (
+		this: PluginContext,
+		outputOptions: OutputOptions,
+		inputOptions: InputOptions
+	) => Promise<void> | void;
+	/** @deprecated Use `resolveFileUrl` instead */
+	resolveAssetUrl: ResolveAssetUrlHook;
+	resolveDynamicImport: ResolveDynamicImportHook;
+	resolveFileUrl: ResolveFileUrlHook;
+	/** @deprecated Use `renderChunk` instead */
+	transformBundle: TransformChunkHook;
+	/** @deprecated Use `renderChunk` instead */
+	transformChunk: TransformChunkHook;
+	writeBundle: (this: PluginContext, bundle: OutputBundle) => void | Promise<void>;
+}
+
+export interface PluginHooks extends OutputPluginHooks {
+	buildEnd: (this: PluginContext, err?: Error) => Promise<void> | void;
+	buildStart: (this: PluginContext, options: InputOptions) => Promise<void> | void;
+	load: LoadHook;
+	options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | null | undefined;
+	resolveId: ResolveIdHook;
+	resolveImportMeta: ResolveImportMetaHook;
+	transform: TransformHook;
+	watchChange: (id: string) => void;
+}
+
+interface OutputPluginValueHooks {
+	banner: AddonHook;
+	cacheKey: string;
+	footer: AddonHook;
+	intro: AddonHook;
+	outro: AddonHook;
+}
+
+export interface Plugin extends Partial<PluginHooks>, Partial<OutputPluginValueHooks> {
+	name: string;
+}
+
+export interface OutputPlugin extends Partial<OutputPluginHooks>, Partial<OutputPluginValueHooks> {
+	name: string;
+}
+
+export interface TreeshakingOptions {
+	annotations?: boolean;
+	moduleSideEffects?: ModuleSideEffectsOption;
+	propertyReadSideEffects?: boolean;
+	/** @deprecated Use `moduleSideEffects` instead */
+	pureExternalModules?: PureModulesOption;
+	tryCatchDeoptimization?: boolean;
+	unknownGlobalSideEffects?: boolean;
+}
+
+export type GetManualChunk = (id: string) => string | null | undefined;
+
+export type ExternalOption = string[] | IsExternal;
+export type PureModulesOption = boolean | string[] | IsPureModule;
+export type GlobalsOption = { [name: string]: string } | ((name: string) => string);
+export type InputOption = string | string[] | { [entryAlias: string]: string };
+export type ManualChunksOption = { [chunkAlias: string]: string[] } | GetManualChunk;
+export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects;
+
+export interface InputOptions {
+	acorn?: any;
+	acornInjectPlugins?: Function[];
+	cache?: false | RollupCache;
+	chunkGroupingSize?: number;
+	context?: string;
+	experimentalCacheExpiry?: number;
+	experimentalOptimizeChunks?: boolean;
+	external?: ExternalOption;
+	inlineDynamicImports?: boolean;
+	input?: InputOption;
+	manualChunks?: ManualChunksOption;
+	moduleContext?: ((id: string) => string) | { [id: string]: string };
+	onwarn?: WarningHandlerWithDefault;
+	perf?: boolean;
+	plugins?: Plugin[];
+	preserveModules?: boolean;
+	preserveSymlinks?: boolean;
+	shimMissingExports?: boolean;
+	strictDeprecations?: boolean;
+	treeshake?: boolean | TreeshakingOptions;
+	watch?: WatcherOptions;
+}
+
+export type ModuleFormat =
+	| 'amd'
+	| 'cjs'
+	| 'commonjs'
+	| 'es'
+	| 'esm'
+	| 'iife'
+	| 'module'
+	| 'system'
+	| 'umd';
+
+export type OptionsPaths = Record<string, string> | ((id: string) => string);
+
+export interface OutputOptions {
+	amd?: {
+		define?: string;
+		id?: string;
+	};
+	assetFileNames?: string;
+	banner?: string | (() => string | Promise<string>);
+	chunkFileNames?: string;
+	compact?: boolean;
+	// only required for bundle.write
+	dir?: string;
+	dynamicImportFunction?: string;
+	entryFileNames?: string;
+	esModule?: boolean;
+	exports?: 'default' | 'named' | 'none' | 'auto';
+	extend?: boolean;
+	externalLiveBindings?: boolean;
+	// only required for bundle.write
+	file?: string;
+	footer?: string | (() => string | Promise<string>);
+	// this is optional at the base-level of RollupWatchOptions,
+	// which extends from this interface through config merge
+	format?: ModuleFormat;
+	freeze?: boolean;
+	globals?: GlobalsOption;
+	hoistTransitiveImports?: boolean;
+	indent?: boolean;
+	interop?: boolean;
+	intro?: string | (() => string | Promise<string>);
+	name?: string;
+	namespaceToStringTag?: boolean;
+	noConflict?: boolean;
+	outro?: string | (() => string | Promise<string>);
+	paths?: OptionsPaths;
+	plugins?: OutputPlugin[];
+	preferConst?: boolean;
+	sourcemap?: boolean | 'inline' | 'hidden';
+	sourcemapExcludeSources?: boolean;
+	sourcemapFile?: string;
+	sourcemapPathTransform?: (sourcePath: string) => string;
+	strict?: boolean;
+}
+
+export type WarningHandlerWithDefault = (
+	warning: RollupWarning,
+	defaultHandler: WarningHandler
+) => void;
+export type WarningHandler = (warning: RollupWarning) => void;
+
+export interface SerializedTimings {
+	[label: string]: [number, number, number];
+}
+
+export interface OutputAsset {
+	fileName: string;
+	/** @deprecated Accessing "isAsset" on files in the bundle is deprecated, please use "type === \'asset\'" instead */
+	isAsset: true;
+	source: string | Buffer;
+	type: 'asset';
+}
+
+export interface RenderedModule {
+	originalLength: number;
+	removedExports: string[];
+	renderedExports: string[];
+	renderedLength: number;
+}
+
+export interface PreRenderedChunk {
+	dynamicImports: string[];
+	exports: string[];
+	facadeModuleId: string | null;
+	imports: string[];
+	isDynamicEntry: boolean;
+	isEntry: boolean;
+	modules: {
+		[id: string]: RenderedModule;
+	};
+	name: string;
+}
+
+export interface RenderedChunk extends PreRenderedChunk {
+	fileName: string;
+}
+
+export interface OutputChunk extends RenderedChunk {
+	code: string;
+	map?: SourceMap;
+	type: 'chunk';
+}
+
+export interface SerializablePluginCache {
+	[key: string]: [number, any];
+}
+
+export interface RollupCache {
+	modules: ModuleJSON[];
+	plugins?: Record<string, SerializablePluginCache>;
+}
+
+export interface RollupOutput {
+	output: [OutputChunk, ...(OutputChunk | OutputAsset)[]];
+}
+
+export interface RollupBuild {
+	cache: RollupCache;
+	generate: (outputOptions: OutputOptions) => Promise<RollupOutput>;
+	getTimings?: () => SerializedTimings;
+	watchFiles: string[];
+	write: (options: OutputOptions) => Promise<RollupOutput>;
+}
+
+export interface RollupOptions extends InputOptions {
+	// This is included for compatibility with config files but ignored by rollup.rollup
+	output?: OutputOptions | OutputOptions[];
+}
+
+export function rollup(options: RollupOptions): Promise<RollupBuild>;
+// chokidar watch options
+export interface WatchOptions {
+	alwaysStat?: boolean;
+	atomic?: boolean | number;
+	awaitWriteFinish?:
+		| {
+				pollInterval?: number;
+				stabilityThreshold?: number;
+		  }
+		| boolean;
+	binaryInterval?: number;
+	cwd?: string;
+	depth?: number;
+	disableGlobbing?: boolean;
+	followSymlinks?: boolean;
+	ignored?: any;
+	ignoreInitial?: boolean;
+	ignorePermissionErrors?: boolean;
+	interval?: number;
+	persistent?: boolean;
+	useFsEvents?: boolean;
+	usePolling?: boolean;
+}
+
+export interface WatcherOptions {
+	chokidar?: boolean | WatchOptions;
+	clearScreen?: boolean;
+	exclude?: string[];
+	include?: string[];
+}
+
+export interface RollupWatchOptions extends InputOptions {
+	output?: OutputOptions | OutputOptions[];
+	watch?: WatcherOptions;
+}
+
+interface TypedEventEmitter<T> {
+	addListener<K extends keyof T>(event: K, listener: T[K]): this;
+	emit<K extends keyof T>(event: K, ...args: any[]): boolean;
+	eventNames(): Array<keyof T>;
+	getMaxListeners(): number;
+	listenerCount(type: keyof T): number;
+	listeners<K extends keyof T>(event: K): Array<T[K]>;
+	off<K extends keyof T>(event: K, listener: T[K]): this;
+	on<K extends keyof T>(event: K, listener: T[K]): this;
+	once<K extends keyof T>(event: K, listener: T[K]): this;
+	prependListener<K extends keyof T>(event: K, listener: T[K]): this;
+	prependOnceListener<K extends keyof T>(event: K, listener: T[K]): this;
+	rawListeners<K extends keyof T>(event: K): Array<T[K]>;
+	removeAllListeners<K extends keyof T>(event?: K): this;
+	removeListener<K extends keyof T>(event: K, listener: T[K]): this;
+	setMaxListeners(n: number): this;
+}
+
+export type RollupWatcherEvent =
+	| { code: 'START' }
+	| { code: 'BUNDLE_START'; input: InputOption; output: readonly string[] }
+	| {
+			code: 'BUNDLE_END';
+			duration: number;
+			input: InputOption;
+			output: readonly string[];
+			result: RollupBuild;
+	  }
+	| { code: 'END' }
+	| { code: 'ERROR'; error: RollupError };
+
+export interface RollupWatcher
+	extends TypedEventEmitter<{
+		change: (id: string) => void;
+		event: (event: RollupWatcherEvent) => void;
+		restart: () => void;
+	}> {
+	close(): void;
+}
+
+export function watch(configs: RollupWatchOptions[]): RollupWatcher;

web/node_modules/rollup/dist/rollup.js

@@ -0,0 +1,29 @@
+/*
+  @license
+	Rollup.js v1.32.1
+	Fri, 06 Mar 2020 09:32:39 GMT - commit f458cbf6cb8cfcc1678593d8dc595e4b8757eb6d
+
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rollup_js = require('./shared/node-entry.js');
+require('util');
+require('path');
+require('fs');
+require('acorn');
+require('crypto');
+require('events');
+require('module');
+
+
+
+exports.VERSION = rollup_js.version;
+exports.rollup = rollup_js.rollup;
+exports.watch = rollup_js.watch;
+//# sourceMappingURL=rollup.js.map

web/node_modules/rollup/dist/shared/index.js

@@ -0,0 +1,321 @@
+/*
+  @license
+	Rollup.js v1.32.1
+	Fri, 06 Mar 2020 09:32:05 GMT - commit f458cbf6cb8cfcc1678593d8dc595e4b8757eb6d
+
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+var path = require('path');
+var module$1 = require('module');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+var version = "1.32.1";
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+const absolutePath = /^(?:\/|(?:[A-Za-z]:)?[\\|/])/;
+const relativePath = /^\.?\.\//;
+function isAbsolute(path) {
+    return absolutePath.test(path);
+}
+function isRelative(path) {
+    return relativePath.test(path);
+}
+function normalize(path) {
+    if (path.indexOf('\\') == -1)
+        return path;
+    return path.replace(/\\/g, '/');
+}
+
+function sanitizeFileName(name) {
+    return name.replace(/[\0?*]/g, '_');
+}
+
+function getAliasName(id) {
+    const base = path.basename(id);
+    return base.substr(0, base.length - path.extname(id).length);
+}
+function relativeId(id) {
+    if (typeof process === 'undefined' || !isAbsolute(id))
+        return id;
+    return path.relative(process.cwd(), id);
+}
+function isPlainPathFragment(name) {
+    // not starting with "/", "./", "../"
+    return (name[0] !== '/' &&
+        !(name[0] === '.' && (name[1] === '/' || name[1] === '.')) &&
+        sanitizeFileName(name) === name);
+}
+
+const createGetOption = (config, command) => (name, defaultValue) => command[name] !== undefined
+    ? command[name]
+    : config[name] !== undefined
+        ? config[name]
+        : defaultValue;
+const normalizeObjectOptionValue = (optionValue) => {
+    if (!optionValue) {
+        return optionValue;
+    }
+    if (typeof optionValue !== 'object') {
+        return {};
+    }
+    return optionValue;
+};
+const getObjectOption = (config, command, name) => {
+    const commandOption = normalizeObjectOptionValue(command[name]);
+    const configOption = normalizeObjectOptionValue(config[name]);
+    if (commandOption !== undefined) {
+        return commandOption && configOption ? Object.assign(Object.assign({}, configOption), commandOption) : commandOption;
+    }
+    return configOption;
+};
+function ensureArray(items) {
+    if (Array.isArray(items)) {
+        return items.filter(Boolean);
+    }
+    if (items) {
+        return [items];
+    }
+    return [];
+}
+const defaultOnWarn = warning => {
+    if (typeof warning === 'string') {
+        console.warn(warning);
+    }
+    else {
+        console.warn(warning.message);
+    }
+};
+const getOnWarn = (config, defaultOnWarnHandler = defaultOnWarn) => config.onwarn
+    ? warning => config.onwarn(warning, defaultOnWarnHandler)
+    : defaultOnWarnHandler;
+const getExternal = (config, command) => {
+    const configExternal = config.external;
+    return typeof configExternal === 'function'
+        ? (id, ...rest) => configExternal(id, ...rest) || command.external.indexOf(id) !== -1
+        : (typeof config.external === 'string'
+            ? [configExternal]
+            : Array.isArray(configExternal)
+                ? configExternal
+                : []).concat(command.external);
+};
+const commandAliases = {
+    c: 'config',
+    d: 'dir',
+    e: 'external',
+    f: 'format',
+    g: 'globals',
+    h: 'help',
+    i: 'input',
+    m: 'sourcemap',
+    n: 'name',
+    o: 'file',
+    p: 'plugin',
+    v: 'version',
+    w: 'watch'
+};
+function mergeOptions({ config = {}, command: rawCommandOptions = {}, defaultOnWarnHandler }) {
+    const command = getCommandOptions(rawCommandOptions);
+    const inputOptions = getInputOptions(config, command, defaultOnWarnHandler);
+    if (command.output) {
+        Object.assign(command, command.output);
+    }
+    const output = config.output;
+    const normalizedOutputOptions = Array.isArray(output) ? output : output ? [output] : [];
+    if (normalizedOutputOptions.length === 0)
+        normalizedOutputOptions.push({});
+    const outputOptions = normalizedOutputOptions.map(singleOutputOptions => getOutputOptions(singleOutputOptions, command));
+    const unknownOptionErrors = [];
+    const validInputOptions = Object.keys(inputOptions);
+    addUnknownOptionErrors(unknownOptionErrors, Object.keys(config), validInputOptions, 'input option', /^output$/);
+    const validOutputOptions = Object.keys(outputOptions[0]);
+    addUnknownOptionErrors(unknownOptionErrors, outputOptions.reduce((allKeys, options) => allKeys.concat(Object.keys(options)), []), validOutputOptions, 'output option');
+    const validCliOutputOptions = validOutputOptions.filter(option => option !== 'sourcemapPathTransform');
+    addUnknownOptionErrors(unknownOptionErrors, Object.keys(command), validInputOptions.concat(validCliOutputOptions, Object.keys(commandAliases), 'config', 'environment', 'plugin', 'silent', 'stdin'), 'CLI flag', /^_|output|(config.*)$/);
+    return {
+        inputOptions,
+        optionError: unknownOptionErrors.length > 0 ? unknownOptionErrors.join('\n') : null,
+        outputOptions
+    };
+}
+function addUnknownOptionErrors(errors, options, validOptions, optionType, ignoredKeys = /$./) {
+    const validOptionSet = new Set(validOptions);
+    const unknownOptions = options.filter(key => !validOptionSet.has(key) && !ignoredKeys.test(key));
+    if (unknownOptions.length > 0)
+        errors.push(`Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${Array.from(validOptionSet)
+            .sort()
+            .join(', ')}`);
+}
+function getCommandOptions(rawCommandOptions) {
+    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
+        ? rawCommandOptions.external.split(',')
+        : [];
+    return Object.assign(Object.assign({}, rawCommandOptions), { external, globals: typeof rawCommandOptions.globals === 'string'
+            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
+                const [id, variableName] = globalDefinition.split(':');
+                globals[id] = variableName;
+                if (external.indexOf(id) === -1) {
+                    external.push(id);
+                }
+                return globals;
+            }, Object.create(null))
+            : undefined });
+}
+function getInputOptions(config, command = { external: [], globals: undefined }, defaultOnWarnHandler) {
+    const getOption = createGetOption(config, command);
+    const inputOptions = {
+        acorn: config.acorn,
+        acornInjectPlugins: config.acornInjectPlugins,
+        cache: getOption('cache'),
+        chunkGroupingSize: getOption('chunkGroupingSize', 5000),
+        context: getOption('context'),
+        experimentalCacheExpiry: getOption('experimentalCacheExpiry', 10),
+        experimentalOptimizeChunks: getOption('experimentalOptimizeChunks'),
+        external: getExternal(config, command),
+        inlineDynamicImports: getOption('inlineDynamicImports', false),
+        input: getOption('input', []),
+        manualChunks: getOption('manualChunks'),
+        moduleContext: config.moduleContext,
+        onwarn: getOnWarn(config, defaultOnWarnHandler),
+        perf: getOption('perf', false),
+        plugins: ensureArray(config.plugins),
+        preserveModules: getOption('preserveModules'),
+        preserveSymlinks: getOption('preserveSymlinks'),
+        shimMissingExports: getOption('shimMissingExports'),
+        strictDeprecations: getOption('strictDeprecations', false),
+        treeshake: getObjectOption(config, command, 'treeshake'),
+        watch: config.watch
+    };
+    // support rollup({ cache: prevBuildObject })
+    if (inputOptions.cache && inputOptions.cache.cache)
+        inputOptions.cache = inputOptions.cache.cache;
+    return inputOptions;
+}
+function getOutputOptions(config, command = {}) {
+    const getOption = createGetOption(config, command);
+    let format = getOption('format');
+    // Handle format aliases
+    switch (format) {
+        case undefined:
+        case 'esm':
+        case 'module':
+            format = 'es';
+            break;
+        case 'commonjs':
+            format = 'cjs';
+    }
+    return {
+        amd: Object.assign(Object.assign({}, config.amd), command.amd),
+        assetFileNames: getOption('assetFileNames'),
+        banner: getOption('banner'),
+        chunkFileNames: getOption('chunkFileNames'),
+        compact: getOption('compact', false),
+        dir: getOption('dir'),
+        dynamicImportFunction: getOption('dynamicImportFunction'),
+        entryFileNames: getOption('entryFileNames'),
+        esModule: getOption('esModule', true),
+        exports: getOption('exports'),
+        extend: getOption('extend'),
+        externalLiveBindings: getOption('externalLiveBindings', true),
+        file: getOption('file'),
+        footer: getOption('footer'),
+        format,
+        freeze: getOption('freeze', true),
+        globals: getOption('globals'),
+        hoistTransitiveImports: getOption('hoistTransitiveImports', true),
+        indent: getOption('indent', true),
+        interop: getOption('interop', true),
+        intro: getOption('intro'),
+        name: getOption('name'),
+        namespaceToStringTag: getOption('namespaceToStringTag', false),
+        noConflict: getOption('noConflict'),
+        outro: getOption('outro'),
+        paths: getOption('paths'),
+        plugins: ensureArray(config.plugins),
+        preferConst: getOption('preferConst'),
+        sourcemap: getOption('sourcemap'),
+        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
+        sourcemapFile: getOption('sourcemapFile'),
+        sourcemapPathTransform: getOption('sourcemapPathTransform'),
+        strict: getOption('strict', true)
+    };
+}
+
+var modules = {};
+var getModule = function (dir) {
+    var rootPath = dir ? path.resolve(dir) : process.cwd();
+    var rootName = path.join(rootPath, '@root');
+    var root = modules[rootName];
+    if (!root) {
+        root = new module$1(rootName);
+        root.filename = rootName;
+        root.paths = module$1._nodeModulePaths(rootPath);
+        modules[rootName] = root;
+    }
+    return root;
+};
+var requireRelative = function (requested, relativeTo) {
+    var root = getModule(relativeTo);
+    return root.require(requested);
+};
+requireRelative.resolve = function (requested, relativeTo) {
+    var root = getModule(relativeTo);
+    return module$1._resolveFilename(requested, root);
+};
+var requireRelative_1 = requireRelative;
+
+exports.__awaiter = __awaiter;
+exports.commandAliases = commandAliases;
+exports.createCommonjsModule = createCommonjsModule;
+exports.ensureArray = ensureArray;
+exports.getAliasName = getAliasName;
+exports.isAbsolute = isAbsolute;
+exports.isPlainPathFragment = isPlainPathFragment;
+exports.isRelative = isRelative;
+exports.mergeOptions = mergeOptions;
+exports.normalize = normalize;
+exports.path = path;
+exports.relative = requireRelative_1;
+exports.relativeId = relativeId;
+exports.sanitizeFileName = sanitizeFileName;
+exports.version = version;
+//# sourceMappingURL=index.js.map