init

node_modules/rollup/dist/es/getLogFilter.js

@@ -0,0 +1,64 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+const getLogFilter = filters => {
+    if (filters.length === 0)
+        return () => true;
+    const normalizedFilters = filters.map(filter => filter.split('&').map(subFilter => {
+        const inverted = subFilter.startsWith('!');
+        if (inverted)
+            subFilter = subFilter.slice(1);
+        const [key, ...value] = subFilter.split(':');
+        return { inverted, key: key.split('.'), parts: value.join(':').split('*') };
+    }));
+    return (log) => {
+        nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+            for (const { inverted, key, parts } of intersectedFilters) {
+                const isFilterSatisfied = testFilter(log, key, parts);
+                if (inverted ? isFilterSatisfied : !isFilterSatisfied) {
+                    continue nextIntersectedFilter;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+};
+const testFilter = (log, key, parts) => {
+    let rawValue = log;
+    for (let index = 0; index < key.length; index++) {
+        if (!rawValue) {
+            return false;
+        }
+        const part = key[index];
+        if (!(part in rawValue)) {
+            return false;
+        }
+        rawValue = rawValue[part];
+    }
+    let value = typeof rawValue === 'object' ? JSON.stringify(rawValue) : String(rawValue);
+    if (parts.length === 1) {
+        return value === parts[0];
+    }
+    if (!value.startsWith(parts[0])) {
+        return false;
+    }
+    const lastPartIndex = parts.length - 1;
+    for (let index = 1; index < lastPartIndex; index++) {
+        const part = parts[index];
+        const position = value.indexOf(part);
+        if (position === -1) {
+            return false;
+        }
+        value = value.slice(position + part.length);
+    }
+    return value.endsWith(parts[lastPartIndex]);
+};
+
+export { getLogFilter };

node_modules/rollup/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/rollup/dist/es/parseAst.js

@@ -0,0 +1,12 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+import '../native.js';
+export { parseAst, parseAstAsync } from './shared/parseAst.js';
+import 'node:path';

node_modules/rollup/dist/es/rollup.js

@@ -0,0 +1,18 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+export { version as VERSION, defineConfig, rollup, watch } from './shared/node-entry.js';
+import './shared/parseAst.js';
+import '../native.js';
+import 'node:path';
+import 'path';
+import 'node:process';
+import 'node:perf_hooks';
+import 'node:fs/promises';
+import 'tty';

node_modules/rollup/dist/getLogFilter.d.ts

@@ -0,0 +1,5 @@
+import type { RollupLog } from './rollup';
+
+export type GetLogFilter = typeof getLogFilter;
+
+export function getLogFilter(filters: string[]): (log: RollupLog) => boolean;

node_modules/rollup/dist/getLogFilter.js

@@ -0,0 +1,69 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getLogFilter = filters => {
+    if (filters.length === 0)
+        return () => true;
+    const normalizedFilters = filters.map(filter => filter.split('&').map(subFilter => {
+        const inverted = subFilter.startsWith('!');
+        if (inverted)
+            subFilter = subFilter.slice(1);
+        const [key, ...value] = subFilter.split(':');
+        return { inverted, key: key.split('.'), parts: value.join(':').split('*') };
+    }));
+    return (log) => {
+        nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+            for (const { inverted, key, parts } of intersectedFilters) {
+                const isFilterSatisfied = testFilter(log, key, parts);
+                if (inverted ? isFilterSatisfied : !isFilterSatisfied) {
+                    continue nextIntersectedFilter;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+};
+const testFilter = (log, key, parts) => {
+    let rawValue = log;
+    for (let index = 0; index < key.length; index++) {
+        if (!rawValue) {
+            return false;
+        }
+        const part = key[index];
+        if (!(part in rawValue)) {
+            return false;
+        }
+        rawValue = rawValue[part];
+    }
+    let value = typeof rawValue === 'object' ? JSON.stringify(rawValue) : String(rawValue);
+    if (parts.length === 1) {
+        return value === parts[0];
+    }
+    if (!value.startsWith(parts[0])) {
+        return false;
+    }
+    const lastPartIndex = parts.length - 1;
+    for (let index = 1; index < lastPartIndex; index++) {
+        const part = parts[index];
+        const position = value.indexOf(part);
+        if (position === -1) {
+            return false;
+        }
+        value = value.slice(position + part.length);
+    }
+    return value.endsWith(parts[lastPartIndex]);
+};
+
+exports.getLogFilter = getLogFilter;
+//# sourceMappingURL=getLogFilter.js.map

node_modules/rollup/dist/loadConfigFile.d.ts

@@ -0,0 +1,20 @@
+import type { LogHandler, MergedRollupOptions, RollupLog } from './rollup';
+
+export interface BatchWarnings {
+	add: (warning: RollupLog) => void;
+	readonly count: number;
+	flush: () => void;
+	log: LogHandler;
+	readonly warningOccurred: boolean;
+}
+
+export type LoadConfigFile = typeof loadConfigFile;
+
+export function loadConfigFile(
+	fileName: string,
+	commandOptions: any,
+	watchMode?: boolean
+): Promise<{
+	options: MergedRollupOptions[];
+	warnings: BatchWarnings;
+}>;

node_modules/rollup/dist/loadConfigFile.js

@@ -0,0 +1,30 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('node:fs/promises');
+require('node:path');
+require('node:process');
+require('node:url');
+require('./shared/rollup.js');
+require('./shared/parseAst.js');
+const loadConfigFile_js = require('./shared/loadConfigFile.js');
+require('tty');
+require('path');
+require('node:perf_hooks');
+require('./native.js');
+require('./getLogFilter.js');
+
+
+
+exports.loadConfigFile = loadConfigFile_js.loadConfigFile;
+//# sourceMappingURL=loadConfigFile.js.map

node_modules/rollup/dist/native.js

@@ -0,0 +1,102 @@
+const { existsSync } = require('node:fs');
+const { join } = require('node:path');
+const { platform, arch, report } = require('node:process');
+
+const isMusl = () => !report.getReport().header.glibcVersionRuntime;
+
+const bindingsByPlatformAndArch = {
+	android: {
+		arm: { base: 'android-arm-eabi' },
+		arm64: { base: 'android-arm64' }
+	},
+	darwin: {
+		arm64: { base: 'darwin-arm64' },
+		x64: { base: 'darwin-x64' }
+	},
+	linux: {
+		arm: { base: 'linux-arm-gnueabihf', musl: null },
+		arm64: { base: 'linux-arm64-gnu', musl: 'linux-arm64-musl' },
+		riscv64: { base: 'linux-riscv64-gnu', musl: null },
+		x64: { base: 'linux-x64-gnu', musl: 'linux-x64-musl' }
+	},
+	win32: {
+		arm64: { base: 'win32-arm64-msvc' },
+		ia32: { base: 'win32-ia32-msvc' },
+		x64: { base: 'win32-x64-msvc' }
+	}
+};
+
+const msvcLinkFilenameByArch = {
+	arm64: 'vc_redist.arm64.exe',
+	ia32: 'vc_redist.x86.exe',
+	x64: 'vc_redist.x64.exe'
+};
+
+const packageBase = getPackageBase();
+
+if (!packageBase) {
+	throw new Error(
+		`Your current platform "${platform}" and architecture "${arch}" combination is not yet supported by the native Rollup build. Please use the WASM build "@rollup/wasm-node" instead.
+
+The following platform-architecture combinations are supported:
+${Object.entries(bindingsByPlatformAndArch)
+	.flatMap(([platformName, architectures]) =>
+		Object.entries(architectures).flatMap(([architectureName, { musl }]) => {
+			const name = `${platformName}-${architectureName}`;
+			return musl ? [name, `${name} (musl)`] : [name];
+		})
+	)
+	.join('\n')}
+
+If this is important to you, please consider supporting Rollup to make a native build for your platform and architecture available.`
+	);
+}
+
+function getPackageBase() {
+	const imported = bindingsByPlatformAndArch[platform]?.[arch];
+	if (!imported) {
+		return null;
+	}
+	if ('musl' in imported && isMusl()) {
+		return imported.musl;
+	}
+	return imported.base;
+}
+
+const localName = `./rollup.${packageBase}.node`;
+const requireWithFriendlyError = id => {
+	try {
+		return require(id);
+	} catch (error) {
+		if (
+			platform === 'win32' &&
+			error instanceof Error &&
+			error.code === 'ERR_DLOPEN_FAILED' &&
+			error.message.includes('The specified module could not be found')
+		) {
+			const msvcDownloadLink = `https://aka.ms/vs/17/release/${msvcLinkFilenameByArch[arch]}`;
+			throw new Error(
+				`Failed to load module ${id}. ` +
+					'Required DLL was not found. ' +
+					'This error usually happens when Microsoft Visual C++ Redistributable is not installed. ' +
+					`You can download it from ${msvcDownloadLink}`,
+				{ cause: error }
+			);
+		}
+
+		throw new Error(
+			`Cannot find module ${id}. ` +
+				`npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+				'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+			{ cause: error }
+		);
+	}
+};
+
+const { parse, parseAsync, xxhashBase64Url } = requireWithFriendlyError(
+	existsSync(join(__dirname, localName)) ? localName : `@rollup/rollup-${packageBase}`
+);
+
+module.exports.parse = parse;
+module.exports.parseAsync = parseAsync;
+module.exports.xxhashBase64Url = xxhashBase64Url;

node_modules/rollup/dist/parseAst.d.ts

@@ -0,0 +1,4 @@
+import type { ParseAst, ParseAstAsync } from './rollup';
+
+export const parseAst: ParseAst;
+export const parseAstAsync: ParseAstAsync;

node_modules/rollup/dist/parseAst.js

@@ -0,0 +1,22 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('./native.js');
+const parseAst_js = require('./shared/parseAst.js');
+require('node:path');
+
+
+
+exports.parseAst = parseAst_js.parseAst;
+exports.parseAstAsync = parseAst_js.parseAstAsync;
+//# sourceMappingURL=parseAst.js.map

node_modules/rollup/dist/rollup.d.ts

@@ -0,0 +1,990 @@
+import type { Program } from 'estree';
+
+export const VERSION: string;
+
+// utils
+type NullValue = null | undefined | void;
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+export interface RollupError extends RollupLog {
+	name?: string;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+export interface RollupLog {
+	binding?: string;
+	cause?: unknown;
+	code?: string;
+	exporter?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	ids?: string[];
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	meta?: any;
+	names?: string[];
+	plugin?: string;
+	pluginCode?: unknown;
+	pos?: number;
+	reexporter?: string;
+	stack?: string;
+	url?: string;
+}
+
+export type LogLevel = 'warn' | 'info' | 'debug';
+export type LogLevelOption = LogLevel | 'silent';
+
+export type SourceMapSegment =
+	| [number]
+	| [number, number, number, number]
+	| [number, number, number, number, number];
+
+export interface ExistingDecodedSourceMap {
+	file?: string;
+	readonly mappings: SourceMapSegment[][];
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	x_google_ignoreList?: number[];
+}
+
+export interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	x_google_ignoreList?: number[];
+}
+
+export type DecodedSourceMapOrMissing =
+	| {
+			missing: true;
+			plugin: string;
+	  }
+	| (ExistingDecodedSourceMap & { missing?: false });
+
+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: '' };
+
+interface ModuleOptions {
+	attributes: Record<string, string>;
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+	ast?: ProgramNode;
+	code: string;
+	map?: SourceMapInput;
+}
+
+export interface TransformModuleJSON {
+	ast?: ProgramNode;
+	code: string;
+	// note if plugins use new this.cache to opt-out auto transform cache
+	customTransformCache: boolean;
+	originalCode: string;
+	originalSourcemap: ExistingDecodedSourceMap | null;
+	sourcemapChain: DecodedSourceMapOrMissing[];
+	transformDependencies: string[];
+}
+
+export interface ModuleJSON extends TransformModuleJSON, ModuleOptions {
+	ast: ProgramNode;
+	dependencies: string[];
+	id: string;
+	resolvedIds: ResolvedIdMap;
+	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 type LoggingFunction = (log: RollupLog | string | (() => RollupLog | string)) => void;
+
+export interface MinimalPluginContext {
+	debug: LoggingFunction;
+	error: (error: RollupError | string) => never;
+	info: LoggingFunction;
+	meta: PluginContextMeta;
+	warn: LoggingFunction;
+}
+
+export interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	needsCodeReference?: boolean;
+	source?: string | Uint8Array;
+	type: 'asset';
+}
+
+export interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	implicitlyLoadedAfterOneOf?: string[];
+	importer?: string;
+	name?: string;
+	preserveSignature?: PreserveEntrySignaturesOption;
+	type: 'chunk';
+}
+
+export interface EmittedPrebuiltChunk {
+	code: string;
+	exports?: string[];
+	fileName: string;
+	map?: SourceMap;
+	sourcemapFileName?: string;
+	type: 'prebuilt-chunk';
+}
+
+export type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk;
+
+export type EmitFile = (emittedFile: EmittedFile) => string;
+
+interface ModuleInfo extends ModuleOptions {
+	ast: ProgramNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	exportedBindings: Record<string, string[]> | null;
+	exports: string[] | null;
+	hasDefaultExport: boolean | null;
+	id: string;
+	implicitlyLoadedAfterOneOf: readonly string[];
+	implicitlyLoadedBefore: readonly string[];
+	importedIdResolutions: readonly ResolvedId[];
+	importedIds: readonly string[];
+	importers: readonly string[];
+	isEntry: boolean;
+	isExternal: boolean;
+	isIncluded: boolean | null;
+}
+
+export type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+
+export interface CustomPluginOptions {
+	[plugin: string]: any;
+}
+
+type LoggingFunctionWithPosition = (
+	log: RollupLog | string | (() => RollupLog | string),
+	pos?: number | { column: number; line: number }
+) => void;
+
+export type ParseAst = (
+	input: string,
+	options?: { allowReturnOutsideFunction?: boolean }
+) => ProgramNode;
+
+// declare AbortSignal here for environments without DOM lib or @types/node
+declare global {
+	interface AbortSignal {}
+}
+
+export type ParseAstAsync = (
+	input: string,
+	options?: { allowReturnOutsideFunction?: boolean; signal?: AbortSignal }
+) => Promise<ProgramNode>;
+
+export interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	debug: LoggingFunction;
+	emitFile: EmitFile;
+	error: (error: RollupError | string) => never;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+	getWatchFiles: () => string[];
+	info: LoggingFunction;
+	load: (
+		options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
+	) => Promise<ModuleInfo>;
+	parse: ParseAst;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: {
+			attributes?: Record<string, string>;
+			custom?: CustomPluginOptions;
+			isEntry?: boolean;
+			skipSelf?: boolean;
+		}
+	) => Promise<ResolvedId | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
+	warn: LoggingFunction;
+}
+
+export interface PluginContextMeta {
+	rollupVersion: string;
+	watchMode: boolean;
+}
+
+export interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
+	resolvedBy: string;
+}
+
+export interface ResolvedIdMap {
+	[key: string]: ResolvedId;
+}
+
+interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
+	external?: boolean | 'absolute' | 'relative';
+	id: string;
+	resolvedBy?: string;
+}
+
+export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+
+export type ResolveIdResultWithoutNullValue = string | false | PartialResolvedId;
+
+export type ResolveIdHook = (
+	this: PluginContext,
+	source: string,
+	importer: string | undefined,
+	options: { attributes: Record<string, string>; custom?: CustomPluginOptions; isEntry: boolean }
+) => ResolveIdResult;
+
+export type ShouldTransformCachedModuleHook = (
+	this: PluginContext,
+	options: {
+		ast: ProgramNode;
+		code: string;
+		id: string;
+		meta: CustomPluginOptions;
+		moduleSideEffects: boolean | 'no-treeshake';
+		resolvedSources: ResolvedIdMap;
+		syntheticNamedExports: boolean | string;
+	}
+) => boolean | NullValue;
+
+export type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+export type HasModuleSideEffects = (id: string, external: boolean) => boolean;
+
+export type LoadResult = SourceDescription | string | NullValue;
+
+export type LoadHook = (this: PluginContext, id: string) => LoadResult;
+
+export interface TransformPluginContext extends PluginContext {
+	debug: LoggingFunctionWithPosition;
+	error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	getCombinedSourcemap: () => SourceMap;
+	info: LoggingFunctionWithPosition;
+	warn: LoggingFunctionWithPosition;
+}
+
+export type TransformResult = string | NullValue | Partial<SourceDescription>;
+
+export type TransformHook = (
+	this: TransformPluginContext,
+	code: string,
+	id: string
+) => TransformResult;
+
+export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void;
+
+export type RenderChunkHook = (
+	this: PluginContext,
+	code: string,
+	chunk: RenderedChunk,
+	options: NormalizedOutputOptions,
+	meta: { chunks: Record<string, RenderedChunk> }
+) => { code: string; map?: SourceMapInput } | string | NullValue;
+
+export type ResolveDynamicImportHook = (
+	this: PluginContext,
+	specifier: string | AstNode,
+	importer: string,
+	options: { attributes: Record<string, string> }
+) => ResolveIdResult;
+
+export type ResolveImportMetaHook = (
+	this: PluginContext,
+	property: string | null,
+	options: { chunkId: string; format: InternalModuleFormat; moduleId: string }
+) => string | NullValue;
+
+export type ResolveFileUrlHook = (
+	this: PluginContext,
+	options: {
+		chunkId: string;
+		fileName: string;
+		format: InternalModuleFormat;
+		moduleId: string;
+		referenceId: string;
+		relativePath: string;
+	}
+) => string | NullValue;
+
+export type AddonHookFunction = (
+	this: PluginContext,
+	chunk: RenderedChunk
+) => string | Promise<string>;
+export type AddonHook = string | AddonHookFunction;
+
+export type ChangeEvent = 'create' | 'update' | 'delete';
+export type WatchChangeHook = (
+	this: PluginContext,
+	id: string,
+	change: { event: ChangeEvent }
+) => void;
+
+/**
+ * use this type for plugin annotation
+ * @example
+ * ```ts
+ * interface Options {
+ * ...
+ * }
+ * const myPlugin: PluginImpl<Options> = (options = {}) => { ... }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type PluginImpl<O extends object = object, A = any> = (options?: O) => Plugin<A>;
+
+export interface OutputBundle {
+	[fileName: string]: OutputAsset | OutputChunk;
+}
+
+export interface FunctionPluginHooks {
+	augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void;
+	buildEnd: (this: PluginContext, error?: Error) => void;
+	buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;
+	closeBundle: (this: PluginContext) => void;
+	closeWatcher: (this: PluginContext) => void;
+	generateBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		bundle: OutputBundle,
+		isWrite: boolean
+	) => void;
+	load: LoadHook;
+	moduleParsed: ModuleParsedHook;
+	onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue;
+	options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue;
+	outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue;
+	renderChunk: RenderChunkHook;
+	renderDynamicImport: (
+		this: PluginContext,
+		options: {
+			customResolution: string | null;
+			format: InternalModuleFormat;
+			moduleId: string;
+			targetModuleId: string | null;
+		}
+	) => { left: string; right: string } | NullValue;
+	renderError: (this: PluginContext, error?: Error) => void;
+	renderStart: (
+		this: PluginContext,
+		outputOptions: NormalizedOutputOptions,
+		inputOptions: NormalizedInputOptions
+	) => void;
+	resolveDynamicImport: ResolveDynamicImportHook;
+	resolveFileUrl: ResolveFileUrlHook;
+	resolveId: ResolveIdHook;
+	resolveImportMeta: ResolveImportMetaHook;
+	shouldTransformCachedModule: ShouldTransformCachedModuleHook;
+	transform: TransformHook;
+	watchChange: WatchChangeHook;
+	writeBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		bundle: OutputBundle
+	) => void;
+}
+
+export type OutputPluginHooks =
+	| 'augmentChunkHash'
+	| 'generateBundle'
+	| 'outputOptions'
+	| 'renderChunk'
+	| 'renderDynamicImport'
+	| 'renderError'
+	| 'renderStart'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta'
+	| 'writeBundle';
+
+export type InputPluginHooks = Exclude<keyof FunctionPluginHooks, OutputPluginHooks>;
+
+export type SyncPluginHooks =
+	| 'augmentChunkHash'
+	| 'onLog'
+	| 'outputOptions'
+	| 'renderDynamicImport'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta';
+
+export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
+
+export type FirstPluginHooks =
+	| 'load'
+	| 'renderDynamicImport'
+	| 'resolveDynamicImport'
+	| 'resolveFileUrl'
+	| 'resolveId'
+	| 'resolveImportMeta'
+	| 'shouldTransformCachedModule';
+
+export type SequentialPluginHooks =
+	| 'augmentChunkHash'
+	| 'generateBundle'
+	| 'onLog'
+	| 'options'
+	| 'outputOptions'
+	| 'renderChunk'
+	| 'transform';
+
+export type ParallelPluginHooks = Exclude<
+	keyof FunctionPluginHooks | AddonHooks,
+	FirstPluginHooks | SequentialPluginHooks
+>;
+
+export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro';
+
+type MakeAsync<Function_> = Function_ extends (
+	this: infer This,
+	...parameters: infer Arguments
+) => infer Return
+	? (this: This, ...parameters: Arguments) => Return | Promise<Return>
+	: never;
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type ObjectHook<T, O = {}> = T | ({ handler: T; order?: 'pre' | 'post' | null } & O);
+
+export type PluginHooks = {
+	[K in keyof FunctionPluginHooks]: ObjectHook<
+		K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K],
+		// eslint-disable-next-line @typescript-eslint/ban-types
+		K extends ParallelPluginHooks ? { sequential?: boolean } : {}
+	>;
+};
+
+export interface OutputPlugin
+	extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
+		Partial<{ [K in AddonHooks]: ObjectHook<AddonHook> }> {
+	cacheKey?: string;
+	name: string;
+	version?: string;
+}
+
+export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
+	// for inter-plugin communication
+	api?: A;
+}
+
+export type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';
+
+export interface NormalizedTreeshakingOptions {
+	annotations: boolean;
+	correctVarValueBeforeDeclaration: boolean;
+	manualPureFunctions: readonly string[];
+	moduleSideEffects: HasModuleSideEffects;
+	propertyReadSideEffects: boolean | 'always';
+	tryCatchDeoptimization: boolean;
+	unknownGlobalSideEffects: boolean;
+}
+
+export interface TreeshakingOptions
+	extends Partial<Omit<NormalizedTreeshakingOptions, 'moduleSideEffects'>> {
+	moduleSideEffects?: ModuleSideEffectsOption;
+	preset?: TreeshakingPreset;
+}
+
+interface ManualChunkMeta {
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+}
+export type GetManualChunk = (id: string, meta: ManualChunkMeta) => string | NullValue;
+
+export type ExternalOption =
+	| (string | RegExp)[]
+	| string
+	| RegExp
+	| ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue);
+
+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 LogHandlerWithDefault = (
+	level: LogLevel,
+	log: RollupLog,
+	defaultHandler: LogOrStringHandler
+) => void;
+
+export type LogOrStringHandler = (level: LogLevel | 'error', log: RollupLog | string) => void;
+
+export type LogHandler = (level: LogLevel, log: RollupLog) => void;
+
+export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects;
+
+export type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+export type SourcemapPathTransformOption = (
+	relativeSourcePath: string,
+	sourcemapPath: string
+) => string;
+
+export type SourcemapIgnoreListOption = (
+	relativeSourcePath: string,
+	sourcemapPath: string
+) => boolean;
+
+export type InputPluginOption = MaybePromise<Plugin | NullValue | false | InputPluginOption[]>;
+
+export interface InputOptions {
+	cache?: boolean | RollupCache;
+	context?: string;
+	experimentalCacheExpiry?: number;
+	experimentalLogSideEffects?: boolean;
+	external?: ExternalOption;
+	input?: InputOption;
+	logLevel?: LogLevelOption;
+	makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource';
+	maxParallelFileOps?: number;
+	moduleContext?: ((id: string) => string | NullValue) | { [id: string]: string };
+	onLog?: LogHandlerWithDefault;
+	onwarn?: WarningHandlerWithDefault;
+	perf?: boolean;
+	plugins?: InputPluginOption;
+	preserveEntrySignatures?: PreserveEntrySignaturesOption;
+	preserveSymlinks?: boolean;
+	shimMissingExports?: boolean;
+	strictDeprecations?: boolean;
+	treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;
+	watch?: WatcherOptions | false;
+}
+
+export interface InputOptionsWithPlugins extends InputOptions {
+	plugins: Plugin[];
+}
+
+export interface NormalizedInputOptions {
+	cache: false | undefined | RollupCache;
+	context: string;
+	experimentalCacheExpiry: number;
+	experimentalLogSideEffects: boolean;
+	external: IsExternal;
+	input: string[] | { [entryAlias: string]: string };
+	logLevel: LogLevelOption;
+	makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource';
+	maxParallelFileOps: number;
+	moduleContext: (id: string) => string;
+	onLog: LogHandler;
+	perf: boolean;
+	plugins: Plugin[];
+	preserveEntrySignatures: PreserveEntrySignaturesOption;
+	preserveSymlinks: boolean;
+	shimMissingExports: boolean;
+	strictDeprecations: boolean;
+	treeshake: false | NormalizedTreeshakingOptions;
+}
+
+export type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd';
+
+export type ModuleFormat = InternalModuleFormat | 'commonjs' | 'esm' | 'module' | 'systemjs';
+
+type GeneratedCodePreset = 'es5' | 'es2015';
+
+interface NormalizedGeneratedCodeOptions {
+	arrowFunctions: boolean;
+	constBindings: boolean;
+	objectShorthand: boolean;
+	reservedNamesAsProps: boolean;
+	symbols: boolean;
+}
+
+interface GeneratedCodeOptions extends Partial<NormalizedGeneratedCodeOptions> {
+	preset?: GeneratedCodePreset;
+}
+
+export type OptionsPaths = Record<string, string> | ((id: string) => string);
+
+export type InteropType = 'compat' | 'auto' | 'esModule' | 'default' | 'defaultOnly';
+
+export type GetInterop = (id: string | null) => InteropType;
+
+export type AmdOptions = (
+	| {
+			autoId?: false;
+			id: string;
+	  }
+	| {
+			autoId: true;
+			basePath?: string;
+			id?: undefined;
+	  }
+	| {
+			autoId?: false;
+			id?: undefined;
+	  }
+) & {
+	define?: string;
+	forceJsExtensionForImports?: boolean;
+};
+
+export type NormalizedAmdOptions = (
+	| {
+			autoId: false;
+			id?: string;
+	  }
+	| {
+			autoId: true;
+			basePath: string;
+	  }
+) & {
+	define: string;
+	forceJsExtensionForImports: boolean;
+};
+
+type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
+
+type OutputPluginOption = MaybePromise<OutputPlugin | NullValue | false | OutputPluginOption[]>;
+
+export interface OutputOptions {
+	amd?: AmdOptions;
+	assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner?: string | AddonFunction;
+	chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact?: boolean;
+	// only required for bundle.write
+	dir?: string;
+	dynamicImportInCjs?: boolean;
+	entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule?: boolean | 'if-default-prop';
+	experimentalMinChunkSize?: number;
+	exports?: 'default' | 'named' | 'none' | 'auto';
+	extend?: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions?: boolean;
+	externalImportAttributes?: boolean;
+	externalLiveBindings?: boolean;
+	// only required for bundle.write
+	file?: string;
+	footer?: string | AddonFunction;
+	format?: ModuleFormat;
+	freeze?: boolean;
+	generatedCode?: GeneratedCodePreset | GeneratedCodeOptions;
+	globals?: GlobalsOption;
+	hoistTransitiveImports?: boolean;
+	indent?: string | boolean;
+	inlineDynamicImports?: boolean;
+	interop?: InteropType | GetInterop;
+	intro?: string | AddonFunction;
+	manualChunks?: ManualChunksOption;
+	minifyInternalExports?: boolean;
+	name?: string;
+	noConflict?: boolean;
+	outro?: string | AddonFunction;
+	paths?: OptionsPaths;
+	plugins?: OutputPluginOption;
+	preserveModules?: boolean;
+	preserveModulesRoot?: string;
+	sanitizeFileName?: boolean | ((fileName: string) => string);
+	sourcemap?: boolean | 'inline' | 'hidden';
+	sourcemapBaseUrl?: string;
+	sourcemapExcludeSources?: boolean;
+	sourcemapFile?: string;
+	sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption;
+	sourcemapPathTransform?: SourcemapPathTransformOption;
+	strict?: boolean;
+	systemNullSetters?: boolean;
+	validate?: boolean;
+}
+
+export interface NormalizedOutputOptions {
+	amd: NormalizedAmdOptions;
+	assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner: AddonFunction;
+	chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact: boolean;
+	dir: string | undefined;
+	dynamicImportInCjs: boolean;
+	entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule: boolean | 'if-default-prop';
+	experimentalMinChunkSize: number;
+	exports: 'default' | 'named' | 'none' | 'auto';
+	extend: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions: boolean;
+	externalImportAttributes: boolean;
+	externalLiveBindings: boolean;
+	file: string | undefined;
+	footer: AddonFunction;
+	format: InternalModuleFormat;
+	freeze: boolean;
+	generatedCode: NormalizedGeneratedCodeOptions;
+	globals: GlobalsOption;
+	hoistTransitiveImports: boolean;
+	indent: true | string;
+	inlineDynamicImports: boolean;
+	interop: GetInterop;
+	intro: AddonFunction;
+	manualChunks: ManualChunksOption;
+	minifyInternalExports: boolean;
+	name: string | undefined;
+	noConflict: boolean;
+	outro: AddonFunction;
+	paths: OptionsPaths;
+	plugins: OutputPlugin[];
+	preserveModules: boolean;
+	preserveModulesRoot: string | undefined;
+	sanitizeFileName: (fileName: string) => string;
+	sourcemap: boolean | 'inline' | 'hidden';
+	sourcemapBaseUrl: string | undefined;
+	sourcemapExcludeSources: boolean;
+	sourcemapFile: string | undefined;
+	sourcemapFileNames: string | ((chunkInfo: PreRenderedChunk) => string) | undefined;
+	sourcemapIgnoreList: SourcemapIgnoreListOption;
+	sourcemapPathTransform: SourcemapPathTransformOption | undefined;
+	strict: boolean;
+	systemNullSetters: boolean;
+	validate: boolean;
+}
+
+export type WarningHandlerWithDefault = (
+	warning: RollupLog,
+	defaultHandler: LoggingFunction
+) => void;
+
+export interface SerializedTimings {
+	[label: string]: [number, number, number];
+}
+
+export interface PreRenderedAsset {
+	name: string | undefined;
+	source: string | Uint8Array;
+	type: 'asset';
+}
+
+export interface OutputAsset extends PreRenderedAsset {
+	fileName: string;
+	needsCodeReference: boolean;
+}
+
+export interface RenderedModule {
+	readonly code: string | null;
+	originalLength: number;
+	removedExports: string[];
+	renderedExports: string[];
+	renderedLength: number;
+}
+
+export interface PreRenderedChunk {
+	exports: string[];
+	facadeModuleId: string | null;
+	isDynamicEntry: boolean;
+	isEntry: boolean;
+	isImplicitEntry: boolean;
+	moduleIds: string[];
+	name: string;
+	type: 'chunk';
+}
+
+export interface RenderedChunk extends PreRenderedChunk {
+	dynamicImports: string[];
+	fileName: string;
+	implicitlyLoadedBefore: string[];
+	importedBindings: {
+		[imported: string]: string[];
+	};
+	imports: string[];
+	modules: {
+		[id: string]: RenderedModule;
+	};
+	referencedFiles: string[];
+}
+
+export interface OutputChunk extends RenderedChunk {
+	code: string;
+	map: SourceMap | null;
+	sourcemapFileName: string | null;
+	preliminaryFileName: string;
+}
+
+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 | undefined;
+	close: () => Promise<void>;
+	closed: boolean;
+	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 interface MergedRollupOptions extends InputOptionsWithPlugins {
+	output: OutputOptions[];
+}
+
+export function rollup(options: RollupOptions): Promise<RollupBuild>;
+
+export interface ChokidarOptions {
+	alwaysStat?: boolean;
+	atomic?: boolean | number;
+	awaitWriteFinish?:
+		| {
+				pollInterval?: number;
+				stabilityThreshold?: number;
+		  }
+		| boolean;
+	binaryInterval?: number;
+	cwd?: string;
+	depth?: number;
+	disableGlobbing?: boolean;
+	followSymlinks?: boolean;
+	ignoreInitial?: boolean;
+	ignorePermissionErrors?: boolean;
+	ignored?: any;
+	interval?: number;
+	persistent?: boolean;
+	useFsEvents?: boolean;
+	usePolling?: boolean;
+}
+
+export type RollupWatchHooks = 'onError' | 'onStart' | 'onBundleStart' | 'onBundleEnd' | 'onEnd';
+
+export interface WatcherOptions {
+	buildDelay?: number;
+	chokidar?: ChokidarOptions;
+	clearScreen?: boolean;
+	exclude?: string | RegExp | (string | RegExp)[];
+	include?: string | RegExp | (string | RegExp)[];
+	skipWrite?: boolean;
+}
+
+export interface RollupWatchOptions extends InputOptions {
+	output?: OutputOptions | OutputOptions[];
+	watch?: WatcherOptions | false;
+}
+
+export type AwaitedEventListener<
+	T extends { [event: string]: (...parameters: any) => any },
+	K extends keyof T
+> = (...parameters: Parameters<T[K]>) => void | Promise<void>;
+
+export interface AwaitingEventEmitter<T extends { [event: string]: (...parameters: any) => any }> {
+	close(): Promise<void>;
+	emit<K extends keyof T>(event: K, ...parameters: Parameters<T[K]>): Promise<unknown>;
+	/**
+	 * Removes an event listener.
+	 */
+	off<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
+	/**
+	 * Registers an event listener that will be awaited before Rollup continues.
+	 * All listeners will be awaited in parallel while rejections are tracked via
+	 * Promise.all.
+	 */
+	on<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
+	/**
+	 * Registers an event listener that will be awaited before Rollup continues.
+	 * All listeners will be awaited in parallel while rejections are tracked via
+	 * Promise.all.
+	 * Listeners are removed automatically when removeListenersForCurrentRun is
+	 * called, which happens automatically after each run.
+	 */
+	onCurrentRun<K extends keyof T>(
+		event: K,
+		listener: (...parameters: Parameters<T[K]>) => Promise<ReturnType<T[K]>>
+	): this;
+	removeAllListeners(): this;
+	removeListenersForCurrentRun(): 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; result: RollupBuild | null };
+
+export type RollupWatcher = AwaitingEventEmitter<{
+	change: (id: string, change: { event: ChangeEvent }) => void;
+	close: () => void;
+	event: (event: RollupWatcherEvent) => void;
+	restart: () => void;
+}>;
+
+export function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher;
+
+interface AstNode {
+	end: number;
+	start: number;
+	type: string;
+}
+
+type ProgramNode = Program & AstNode;
+
+export function defineConfig(options: RollupOptions): RollupOptions;
+export function defineConfig(options: RollupOptions[]): RollupOptions[];
+export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction;
+
+export type RollupOptionsFunction = (
+	commandLineArguments: Record<string, any>
+) => MaybePromise<RollupOptions | RollupOptions[]>;

node_modules/rollup/dist/rollup.js

@@ -0,0 +1,100 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const rollup = require('./shared/rollup.js');
+const parseAst_js = require('./shared/parseAst.js');
+const fseventsImporter = require('./shared/fsevents-importer.js');
+require('node:process');
+require('tty');
+require('node:path');
+require('path');
+require('node:perf_hooks');
+require('./native.js');
+require('node:fs/promises');
+
+class WatchEmitter {
+    constructor() {
+        this.currentHandlers = Object.create(null);
+        this.persistentHandlers = Object.create(null);
+    }
+    // Will be overwritten by Rollup
+    async close() { }
+    emit(event, ...parameters) {
+        return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
+    }
+    off(event, listener) {
+        const listeners = this.persistentHandlers[event];
+        if (listeners) {
+            // A hack stolen from "mitt": ">>> 0" does not change numbers >= 0, but -1
+            // (which would remove the last array element if used unchanged) is turned
+            // into max_int, which is outside the array and does not change anything.
+            listeners.splice(listeners.indexOf(listener) >>> 0, 1);
+        }
+        return this;
+    }
+    on(event, listener) {
+        this.getPersistentHandlers(event).push(listener);
+        return this;
+    }
+    onCurrentRun(event, listener) {
+        this.getCurrentHandlers(event).push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const selfRemovingListener = (...parameters) => {
+            this.off(event, selfRemovingListener);
+            return listener(...parameters);
+        };
+        this.on(event, selfRemovingListener);
+        return this;
+    }
+    removeAllListeners() {
+        this.removeListenersForCurrentRun();
+        this.persistentHandlers = Object.create(null);
+        return this;
+    }
+    removeListenersForCurrentRun() {
+        this.currentHandlers = Object.create(null);
+        return this;
+    }
+    getCurrentHandlers(event) {
+        return this.currentHandlers[event] || (this.currentHandlers[event] = []);
+    }
+    getPersistentHandlers(event) {
+        return this.persistentHandlers[event] || (this.persistentHandlers[event] = []);
+    }
+}
+
+function watch(configs) {
+    const emitter = new WatchEmitter();
+    watchInternal(configs, emitter).catch(error => {
+        rollup.handleError(error);
+    });
+    return emitter;
+}
+async function watchInternal(configs, emitter) {
+    const optionsList = await Promise.all(rollup.ensureArray(configs).map(config => rollup.mergeOptions(config, true)));
+    const watchOptionsList = optionsList.filter(config => config.watch !== false);
+    if (watchOptionsList.length === 0) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('watch', parseAst_js.URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
+    }
+    await fseventsImporter.loadFsEvents();
+    const { Watcher } = await Promise.resolve().then(() => require('./shared/watch.js'));
+    new Watcher(watchOptionsList, emitter);
+}
+
+exports.VERSION = rollup.version;
+exports.defineConfig = rollup.defineConfig;
+exports.rollup = rollup.rollup;
+exports.watch = watch;
+//# sourceMappingURL=rollup.js.map

node_modules/rollup/dist/shared/fsevents-importer.js

@@ -0,0 +1,37 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+let fsEvents;
+let fsEventsImportError;
+async function loadFsEvents() {
+    try {
+        ({ default: fsEvents } = await import('fsevents'));
+    }
+    catch (error) {
+        fsEventsImportError = error;
+    }
+}
+// A call to this function will be injected into the chokidar code
+function getFsEvents() {
+    if (fsEventsImportError)
+        throw fsEventsImportError;
+    return fsEvents;
+}
+
+const fseventsImporter = /*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getFsEvents,
+    loadFsEvents
+}, Symbol.toStringTag, { value: 'Module' });
+
+exports.fseventsImporter = fseventsImporter;
+exports.loadFsEvents = loadFsEvents;
+//# sourceMappingURL=fsevents-importer.js.map

node_modules/rollup/dist/shared/loadConfigFile.js

@@ -0,0 +1,546 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const promises = require('node:fs/promises');
+const node_path = require('node:path');
+const process$1 = require('node:process');
+const node_url = require('node:url');
+const rollup = require('./rollup.js');
+const parseAst_js = require('./parseAst.js');
+const getLogFilter_js = require('../getLogFilter.js');
+
+function batchWarnings(command) {
+    const silent = !!command.silent;
+    const logFilter = generateLogFilter(command);
+    let count = 0;
+    const deferredWarnings = new Map();
+    let warningOccurred = false;
+    const add = (warning) => {
+        count += 1;
+        warningOccurred = true;
+        if (silent)
+            return;
+        if (warning.code in deferredHandlers) {
+            rollup.getOrCreate(deferredWarnings, warning.code, rollup.getNewArray).push(warning);
+        }
+        else if (warning.code in immediateHandlers) {
+            immediateHandlers[warning.code](warning);
+        }
+        else {
+            title(warning.message);
+            defaultBody(warning);
+        }
+    };
+    return {
+        add,
+        get count() {
+            return count;
+        },
+        flush() {
+            if (count === 0 || silent)
+                return;
+            const codes = [...deferredWarnings.keys()].sort((a, b) => deferredWarnings.get(b).length - deferredWarnings.get(a).length);
+            for (const code of codes) {
+                deferredHandlers[code](deferredWarnings.get(code));
+            }
+            deferredWarnings.clear();
+            count = 0;
+        },
+        log(level, log) {
+            if (!logFilter(log))
+                return;
+            switch (level) {
+                case parseAst_js.LOGLEVEL_WARN: {
+                    return add(log);
+                }
+                case parseAst_js.LOGLEVEL_DEBUG: {
+                    if (!silent) {
+                        rollup.stderr(rollup.bold(rollup.blue(log.message)));
+                        defaultBody(log);
+                    }
+                    return;
+                }
+                default: {
+                    if (!silent) {
+                        rollup.stderr(rollup.bold(rollup.cyan(log.message)));
+                        defaultBody(log);
+                    }
+                }
+            }
+        },
+        get warningOccurred() {
+            return warningOccurred;
+        }
+    };
+}
+const immediateHandlers = {
+    MISSING_NODE_BUILTINS(warning) {
+        title(`Missing shims for Node.js built-ins`);
+        rollup.stderr(`Creating a browser bundle that depends on ${parseAst_js.printQuotedStringList(warning.ids)}. You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`);
+    },
+    UNKNOWN_OPTION(warning) {
+        title(`You have passed an unrecognized option`);
+        rollup.stderr(warning.message);
+    }
+};
+const deferredHandlers = {
+    CIRCULAR_DEPENDENCY(warnings) {
+        title(`Circular dependenc${warnings.length > 1 ? 'ies' : 'y'}`);
+        const displayed = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
+        for (const warning of displayed) {
+            rollup.stderr(warning.ids.map(parseAst_js.relativeId).join(' -> '));
+        }
+        if (warnings.length > displayed.length) {
+            rollup.stderr(`...and ${warnings.length - displayed.length} more`);
+        }
+    },
+    EMPTY_BUNDLE(warnings) {
+        title(`Generated${warnings.length === 1 ? ' an' : ''} empty ${warnings.length > 1 ? 'chunks' : 'chunk'}`);
+        rollup.stderr(parseAst_js.printQuotedStringList(warnings.map(warning => warning.names[0])));
+    },
+    EVAL(warnings) {
+        title('Use of eval is strongly discouraged');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_AVOIDING_EVAL));
+        showTruncatedWarnings(warnings);
+    },
+    MISSING_EXPORT(warnings) {
+        title('Missing exports');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_NAME_IS_NOT_EXPORTED));
+        for (const warning of warnings) {
+            rollup.stderr(rollup.bold(parseAst_js.relativeId(warning.id)));
+            rollup.stderr(`${warning.binding} is not exported by ${parseAst_js.relativeId(warning.exporter)}`);
+            rollup.stderr(rollup.gray(warning.frame));
+        }
+    },
+    MISSING_GLOBAL_NAME(warnings) {
+        title(`Missing global variable ${warnings.length > 1 ? 'names' : 'name'}`);
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_OUTPUT_GLOBALS));
+        rollup.stderr(`Use "output.globals" to specify browser global variable names corresponding to external modules:`);
+        for (const warning of warnings) {
+            rollup.stderr(`${rollup.bold(warning.id)} (guessing "${warning.names[0]}")`);
+        }
+    },
+    MIXED_EXPORTS(warnings) {
+        title('Mixing named and default exports');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_OUTPUT_EXPORTS));
+        rollup.stderr(rollup.bold('The following entry modules are using named and default exports together:'));
+        warnings.sort((a, b) => (a.id < b.id ? -1 : 1));
+        const displayedWarnings = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
+        for (const warning of displayedWarnings) {
+            rollup.stderr(parseAst_js.relativeId(warning.id));
+        }
+        if (displayedWarnings.length < warnings.length) {
+            rollup.stderr(`...and ${warnings.length - displayedWarnings.length} other entry modules`);
+        }
+        rollup.stderr(`\nConsumers of your bundle will have to use chunk.default to access their default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning.`);
+    },
+    NAMESPACE_CONFLICT(warnings) {
+        title(`Conflicting re-exports`);
+        for (const warning of warnings) {
+            rollup.stderr(`"${rollup.bold(parseAst_js.relativeId(warning.reexporter))}" re-exports "${warning.binding}" from both "${parseAst_js.relativeId(warning.ids[0])}" and "${parseAst_js.relativeId(warning.ids[1])}" (will be ignored).`);
+        }
+    },
+    PLUGIN_WARNING(warnings) {
+        const nestedByPlugin = nest(warnings, 'plugin');
+        for (const { key: plugin, items } of nestedByPlugin) {
+            const nestedByMessage = nest(items, 'message');
+            let lastUrl = '';
+            for (const { key: message, items } of nestedByMessage) {
+                title(`Plugin ${plugin}: ${message}`);
+                for (const warning of items) {
+                    if (warning.url && warning.url !== lastUrl)
+                        info((lastUrl = warning.url));
+                    const id = warning.id || warning.loc?.file;
+                    if (id) {
+                        let loc = parseAst_js.relativeId(id);
+                        if (warning.loc) {
+                            loc += `: (${warning.loc.line}:${warning.loc.column})`;
+                        }
+                        rollup.stderr(rollup.bold(loc));
+                    }
+                    if (warning.frame)
+                        info(warning.frame);
+                }
+            }
+        }
+    },
+    SOURCEMAP_BROKEN(warnings) {
+        title(`Broken sourcemap`);
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT));
+        const plugins = [...new Set(warnings.map(({ plugin }) => plugin).filter(Boolean))];
+        rollup.stderr(`Plugins that transform code (such as ${parseAst_js.printQuotedStringList(plugins)}) should generate accompanying sourcemaps.`);
+    },
+    THIS_IS_UNDEFINED(warnings) {
+        title('"this" has been rewritten to "undefined"');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_THIS_IS_UNDEFINED));
+        showTruncatedWarnings(warnings);
+    },
+    UNRESOLVED_IMPORT(warnings) {
+        title('Unresolved dependencies');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY));
+        const dependencies = new Map();
+        for (const warning of warnings) {
+            rollup.getOrCreate(dependencies, parseAst_js.relativeId(warning.exporter), rollup.getNewArray).push(parseAst_js.relativeId(warning.id));
+        }
+        for (const [dependency, importers] of dependencies) {
+            rollup.stderr(`${rollup.bold(dependency)} (imported by ${parseAst_js.printQuotedStringList(importers)})`);
+        }
+    },
+    UNUSED_EXTERNAL_IMPORT(warnings) {
+        title('Unused external imports');
+        for (const warning of warnings) {
+            rollup.stderr(warning.names +
+                ' imported from external module "' +
+                warning.exporter +
+                '" but never used in ' +
+                parseAst_js.printQuotedStringList(warning.ids.map(parseAst_js.relativeId)) +
+                '.');
+        }
+    }
+};
+function defaultBody(log) {
+    if (log.url) {
+        info(parseAst_js.getRollupUrl(log.url));
+    }
+    const id = log.loc?.file || log.id;
+    if (id) {
+        const loc = log.loc ? `${parseAst_js.relativeId(id)} (${log.loc.line}:${log.loc.column})` : parseAst_js.relativeId(id);
+        rollup.stderr(rollup.bold(parseAst_js.relativeId(loc)));
+    }
+    if (log.frame)
+        info(log.frame);
+}
+function title(string_) {
+    rollup.stderr(rollup.bold(rollup.yellow(`(!) ${string_}`)));
+}
+function info(url) {
+    rollup.stderr(rollup.gray(url));
+}
+function nest(array, property) {
+    const nested = [];
+    const lookup = new Map();
+    for (const item of array) {
+        const key = item[property];
+        rollup.getOrCreate(lookup, key, () => {
+            const items = {
+                items: [],
+                key
+            };
+            nested.push(items);
+            return items;
+        }).items.push(item);
+    }
+    return nested;
+}
+function showTruncatedWarnings(warnings) {
+    const nestedByModule = nest(warnings, 'id');
+    const displayedByModule = nestedByModule.length > 5 ? nestedByModule.slice(0, 3) : nestedByModule;
+    for (const { key: id, items } of displayedByModule) {
+        rollup.stderr(rollup.bold(parseAst_js.relativeId(id)));
+        rollup.stderr(rollup.gray(items[0].frame));
+        if (items.length > 1) {
+            rollup.stderr(`...and ${items.length - 1} other ${items.length > 2 ? 'occurrences' : 'occurrence'}`);
+        }
+    }
+    if (nestedByModule.length > displayedByModule.length) {
+        rollup.stderr(`\n...and ${nestedByModule.length - displayedByModule.length} other files`);
+    }
+}
+function generateLogFilter(command) {
+    const filters = rollup.ensureArray(command.filterLogs).flatMap(filter => String(filter).split(','));
+    if (process.env.ROLLUP_FILTER_LOGS) {
+        filters.push(...process.env.ROLLUP_FILTER_LOGS.split(','));
+    }
+    return getLogFilter_js.getLogFilter(filters);
+}
+
+const stdinName = '-';
+let stdinResult = null;
+function stdinPlugin(argument) {
+    const suffix = typeof argument == 'string' && argument.length > 0 ? '.' + argument : '';
+    return {
+        load(id) {
+            if (id === stdinName || id.startsWith(stdinName + '.')) {
+                return stdinResult || (stdinResult = readStdin());
+            }
+        },
+        name: 'stdin',
+        resolveId(id) {
+            if (id === stdinName) {
+                return id + suffix;
+            }
+        }
+    };
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process$1.stdin.setEncoding('utf8');
+        process$1.stdin
+            .on('data', chunk => chunks.push(chunk))
+            .on('end', () => {
+            const result = chunks.join('');
+            resolve(result);
+        })
+            .on('error', error => {
+            reject(error);
+        });
+    });
+}
+
+function waitForInputPlugin() {
+    return {
+        async buildStart(options) {
+            const inputSpecifiers = Array.isArray(options.input)
+                ? options.input
+                : Object.keys(options.input);
+            let lastAwaitedSpecifier = null;
+            checkSpecifiers: while (true) {
+                for (const specifier of inputSpecifiers) {
+                    if ((await this.resolve(specifier)) === null) {
+                        if (lastAwaitedSpecifier !== specifier) {
+                            rollup.stderr(`waiting for input ${rollup.bold(specifier)}...`);
+                            lastAwaitedSpecifier = specifier;
+                        }
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue checkSpecifiers;
+                    }
+                }
+                break;
+            }
+        },
+        name: 'wait-for-input'
+    };
+}
+
+async function addCommandPluginsToInputOptions(inputOptions, command) {
+    if (command.stdin !== false) {
+        inputOptions.plugins.push(stdinPlugin(command.stdin));
+    }
+    if (command.waitForBundleInput === true) {
+        inputOptions.plugins.push(waitForInputPlugin());
+    }
+    await addPluginsFromCommandOption(command.plugin, inputOptions);
+}
+async function addPluginsFromCommandOption(commandPlugin, inputOptions) {
+    if (commandPlugin) {
+        const plugins = await rollup.normalizePluginOption(commandPlugin);
+        for (const plugin of plugins) {
+            if (/[={}]/.test(plugin)) {
+                // -p plugin=value
+                // -p "{transform(c,i){...}}"
+                await loadAndRegisterPlugin(inputOptions, plugin);
+            }
+            else {
+                // split out plugins joined by commas
+                // -p node-resolve,commonjs,buble
+                for (const p of plugin.split(',')) {
+                    await loadAndRegisterPlugin(inputOptions, p);
+                }
+            }
+        }
+    }
+}
+async function loadAndRegisterPlugin(inputOptions, pluginText) {
+    let plugin = null;
+    let pluginArgument = undefined;
+    if (pluginText[0] === '{') {
+        // -p "{transform(c,i){...}}"
+        plugin = new Function('return ' + pluginText);
+    }
+    else {
+        const match = pluginText.match(/^([\w./:@\\^{|}-]+)(=(.*))?$/);
+        if (match) {
+            // -p plugin
+            // -p plugin=arg
+            pluginText = match[1];
+            pluginArgument = new Function('return ' + match[3])();
+        }
+        else {
+            throw new Error(`Invalid --plugin argument format: ${JSON.stringify(pluginText)}`);
+        }
+        if (!/^\.|^rollup-plugin-|[/@\\]/.test(pluginText)) {
+            // Try using plugin prefix variations first if applicable.
+            // Prefix order is significant - left has higher precedence.
+            for (const prefix of ['@rollup/plugin-', 'rollup-plugin-']) {
+                try {
+                    plugin = await requireOrImport(prefix + pluginText);
+                    break;
+                }
+                catch {
+                    // if this does not work, we try requiring the actual name below
+                }
+            }
+        }
+        if (!plugin) {
+            try {
+                if (pluginText[0] == '.')
+                    pluginText = node_path.resolve(pluginText);
+                // Windows absolute paths must be specified as file:// protocol URL
+                // Note that we do not have coverage for Windows-only code paths
+                else if (/^[A-Za-z]:\\/.test(pluginText)) {
+                    pluginText = node_url.pathToFileURL(node_path.resolve(pluginText)).href;
+                }
+                plugin = await requireOrImport(pluginText);
+            }
+            catch (error) {
+                throw new Error(`Cannot load plugin "${pluginText}": ${error.message}.`);
+            }
+        }
+    }
+    // some plugins do not use `module.exports` for their entry point,
+    // in which case we try the named default export and the plugin name
+    if (typeof plugin === 'object') {
+        plugin = plugin.default || plugin[getCamelizedPluginBaseName(pluginText)];
+    }
+    if (!plugin) {
+        throw new Error(`Cannot find entry for plugin "${pluginText}". The plugin needs to export a function either as "default" or "${getCamelizedPluginBaseName(pluginText)}" for Rollup to recognize it.`);
+    }
+    inputOptions.plugins.push(typeof plugin === 'function' ? plugin.call(plugin, pluginArgument) : plugin);
+}
+function getCamelizedPluginBaseName(pluginText) {
+    return (pluginText.match(/(@rollup\/plugin-|rollup-plugin-)(.+)$/)?.[2] || pluginText)
+        .split(/[/\\]/)
+        .slice(-1)[0]
+        .split('.')[0]
+        .split('-')
+        .map((part, index) => (index === 0 || !part ? part : part[0].toUpperCase() + part.slice(1)))
+        .join('');
+}
+async function requireOrImport(pluginPath) {
+    try {
+        // eslint-disable-next-line unicorn/prefer-module
+        return require(pluginPath);
+    }
+    catch {
+        return import(pluginPath);
+    }
+}
+
+const loadConfigFile = async (fileName, commandOptions = {}, watchMode = false) => {
+    const configs = await getConfigList(getDefaultFromCjs(await getConfigFileExport(fileName, commandOptions, watchMode)), commandOptions);
+    const warnings = batchWarnings(commandOptions);
+    try {
+        const normalizedConfigs = [];
+        for (const config of configs) {
+            const options = await rollup.mergeOptions(config, watchMode, commandOptions, warnings.log);
+            await addCommandPluginsToInputOptions(options, commandOptions);
+            normalizedConfigs.push(options);
+        }
+        return { options: normalizedConfigs, warnings };
+    }
+    catch (error_) {
+        warnings.flush();
+        throw error_;
+    }
+};
+async function getConfigFileExport(fileName, commandOptions, watchMode) {
+    if (commandOptions.configPlugin || commandOptions.bundleConfigAsCjs) {
+        try {
+            return await loadTranspiledConfigFile(fileName, commandOptions);
+        }
+        catch (error_) {
+            if (error_.message.includes('not defined in ES module scope')) {
+                return parseAst_js.error(parseAst_js.logCannotBundleConfigAsEsm(error_));
+            }
+            throw error_;
+        }
+    }
+    let cannotLoadEsm = false;
+    const handleWarning = (warning) => {
+        if (warning.message.includes('To load an ES module')) {
+            cannotLoadEsm = true;
+        }
+    };
+    process$1.on('warning', handleWarning);
+    try {
+        const fileUrl = node_url.pathToFileURL(fileName);
+        if (watchMode) {
+            // We are adding the current date to allow reloads in watch mode
+            fileUrl.search = `?${Date.now()}`;
+        }
+        return (await import(fileUrl.href)).default;
+    }
+    catch (error_) {
+        if (cannotLoadEsm) {
+            return parseAst_js.error(parseAst_js.logCannotLoadConfigAsCjs(error_));
+        }
+        if (error_.message.includes('not defined in ES module scope')) {
+            return parseAst_js.error(parseAst_js.logCannotLoadConfigAsEsm(error_));
+        }
+        throw error_;
+    }
+    finally {
+        process$1.off('warning', handleWarning);
+    }
+}
+function getDefaultFromCjs(namespace) {
+    return namespace.default || namespace;
+}
+async function loadTranspiledConfigFile(fileName, commandOptions) {
+    const { bundleConfigAsCjs, configPlugin, silent } = commandOptions;
+    const warnings = batchWarnings(commandOptions);
+    const inputOptions = {
+        external: (id) => (id[0] !== '.' && !node_path.isAbsolute(id)) || id.slice(-5, id.length) === '.json',
+        input: fileName,
+        onwarn: warnings.add,
+        plugins: [],
+        treeshake: false
+    };
+    await addPluginsFromCommandOption(configPlugin, inputOptions);
+    const bundle = await rollup.rollup(inputOptions);
+    const { output: [{ code }] } = await bundle.generate({
+        exports: 'named',
+        format: bundleConfigAsCjs ? 'cjs' : 'es',
+        plugins: [
+            {
+                name: 'transpile-import-meta',
+                resolveImportMeta(property, { moduleId }) {
+                    if (property === 'url') {
+                        return `'${node_url.pathToFileURL(moduleId).href}'`;
+                    }
+                    if (property == null) {
+                        return `{url:'${node_url.pathToFileURL(moduleId).href}'}`;
+                    }
+                }
+            }
+        ]
+    });
+    if (!silent && warnings.count > 0) {
+        rollup.stderr(rollup.bold(`loaded ${parseAst_js.relativeId(fileName)} with warnings`));
+        warnings.flush();
+    }
+    return loadConfigFromWrittenFile(node_path.join(node_path.dirname(fileName), `rollup.config-${Date.now()}.${bundleConfigAsCjs ? 'cjs' : 'mjs'}`), code);
+}
+async function loadConfigFromWrittenFile(bundledFileName, bundledCode) {
+    await promises.writeFile(bundledFileName, bundledCode);
+    try {
+        return (await import(node_url.pathToFileURL(bundledFileName).href)).default;
+    }
+    finally {
+        promises.unlink(bundledFileName).catch(error => console.warn(error?.message || error));
+    }
+}
+async function getConfigList(configFileExport, commandOptions) {
+    const config = await (typeof configFileExport === 'function'
+        ? configFileExport(commandOptions)
+        : configFileExport);
+    if (Object.keys(config).length === 0) {
+        return parseAst_js.error(parseAst_js.logMissingConfig());
+    }
+    return Array.isArray(config) ? config : [config];
+}
+
+exports.addCommandPluginsToInputOptions = addCommandPluginsToInputOptions;
+exports.batchWarnings = batchWarnings;
+exports.loadConfigFile = loadConfigFile;
+exports.stdinName = stdinName;
+//# sourceMappingURL=loadConfigFile.js.map

node_modules/rollup/dist/shared/watch-cli.js

@@ -0,0 +1,562 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const promises = require('node:fs/promises');
+const process$2 = require('node:process');
+const index = require('./index.js');
+const cli = require('../bin/rollup');
+const rollup = require('./rollup.js');
+const parseAst_js = require('./parseAst.js');
+const loadConfigFile_js = require('./loadConfigFile.js');
+const node_child_process = require('node:child_process');
+const rollup_js = require('../rollup.js');
+require('fs');
+require('util');
+require('stream');
+require('path');
+require('os');
+require('./fsevents-importer.js');
+require('events');
+require('node:path');
+require('tty');
+require('node:perf_hooks');
+require('../native.js');
+require('node:url');
+require('../getLogFilter.js');
+
+function timeZone(date = new Date()) {
+	const offset = date.getTimezoneOffset();
+	const absOffset = Math.abs(offset);
+	const hours = Math.floor(absOffset / 60);
+	const minutes = absOffset % 60;
+	const minutesOut = minutes > 0 ? ':' + ('0' + minutes).slice(-2) : '';
+	return (offset < 0 ? '+' : '-') + hours + minutesOut;
+}
+
+function dateTime(options = {}) {
+	let {
+		date = new Date(),
+		local = true,
+		showTimeZone = false,
+		showMilliseconds = false
+	} = options;
+
+	if (local) {
+		// Offset the date so it will return the correct value when getting the ISO string.
+		date = new Date(date.getTime() - (date.getTimezoneOffset() * 60000));
+	}
+
+	let end = '';
+
+	if (showTimeZone) {
+		end = ' UTC' + (local ? timeZone(date) : '');
+	}
+
+	if (showMilliseconds && date.getUTCMilliseconds() > 0) {
+		end = ` ${date.getUTCMilliseconds()}ms${end}`;
+	}
+
+	return date
+		.toISOString()
+		.replace(/T/, ' ')
+		.replace(/\..+/, end);
+}
+
+/**
+ * This is not the set of all possible signals.
+ *
+ * It IS, however, the set of all signals that trigger
+ * an exit on either Linux or BSD systems.  Linux is a
+ * superset of the signal names supported on BSD, and
+ * the unknown signals just fail to register, so we can
+ * catch that easily enough.
+ *
+ * Windows signals are a different set, since there are
+ * signals that terminate Windows processes, but don't
+ * terminate (or don't even exist) on Posix systems.
+ *
+ * Don't bother with SIGKILL.  It's uncatchable, which
+ * means that we can't fire any callbacks anyway.
+ *
+ * If a user does happen to register a handler on a non-
+ * fatal signal like SIGWINCH or something, and then
+ * exit, it'll end up firing `process.emit('exit')`, so
+ * the handler will be fired anyway.
+ *
+ * SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+ * artificially, inherently leave the process in a
+ * state from which it is not safe to try and enter JS
+ * listeners.
+ */
+const signals = [];
+signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
+if (process.platform !== 'win32') {
+    signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+    );
+}
+if (process.platform === 'linux') {
+    signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
+}
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+const processOk = (process) => !!process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function';
+const kExitEmitter = Symbol.for('signal-exit emitter');
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+// teeny special purpose ee
+class Emitter {
+    emitted = {
+        afterExit: false,
+        exit: false,
+    };
+    listeners = {
+        afterExit: [],
+        exit: [],
+    };
+    count = 0;
+    id = Math.random();
+    constructor() {
+        if (global[kExitEmitter]) {
+            return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+            value: this,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    }
+    on(ev, fn) {
+        this.listeners[ev].push(fn);
+    }
+    removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        /* c8 ignore start */
+        if (i === -1) {
+            return;
+        }
+        /* c8 ignore stop */
+        if (i === 0 && list.length === 1) {
+            list.length = 0;
+        }
+        else {
+            list.splice(i, 1);
+        }
+    }
+    emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+            return false;
+        }
+        this.emitted[ev] = true;
+        let ret = false;
+        for (const fn of this.listeners[ev]) {
+            ret = fn(code, signal) === true || ret;
+        }
+        if (ev === 'exit') {
+            ret = this.emit('afterExit', code, signal) || ret;
+        }
+        return ret;
+    }
+}
+class SignalExitBase {
+}
+const signalExitWrap = (handler) => {
+    return {
+        onExit(cb, opts) {
+            return handler.onExit(cb, opts);
+        },
+        load() {
+            return handler.load();
+        },
+        unload() {
+            return handler.unload();
+        },
+    };
+};
+class SignalExitFallback extends SignalExitBase {
+    onExit() {
+        return () => { };
+    }
+    load() { }
+    unload() { }
+}
+class SignalExit extends SignalExitBase {
+    // "SIGHUP" throws an `ENOSYS` error on Windows,
+    // so use a supported signal instead
+    /* c8 ignore start */
+    #hupSig = process$1.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
+    /* c8 ignore stop */
+    #emitter = new Emitter();
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process) {
+        super();
+        this.#process = process;
+        // { <signal>: <listener fn>, ... }
+        this.#sigListeners = {};
+        for (const sig of signals) {
+            this.#sigListeners[sig] = () => {
+                // If there are no other listeners, an exit is coming!
+                // Simplest way: remove us and then re-send the signal.
+                // We know that this will kill the process, so we can
+                // safely emit now.
+                const listeners = this.#process.listeners(sig);
+                let { count } = this.#emitter;
+                // This is a workaround for the fact that signal-exit v3 and signal
+                // exit v4 are not aware of each other, and each will attempt to let
+                // the other handle it, so neither of them do. To correct this, we
+                // detect if we're the only handler *except* for previous versions
+                // of signal-exit, and increment by the count of listeners it has
+                // created.
+                /* c8 ignore start */
+                const p = process;
+                if (typeof p.__signal_exit_emitter__ === 'object' &&
+                    typeof p.__signal_exit_emitter__.count === 'number') {
+                    count += p.__signal_exit_emitter__.count;
+                }
+                /* c8 ignore stop */
+                if (listeners.length === count) {
+                    this.unload();
+                    const ret = this.#emitter.emit('exit', null, sig);
+                    /* c8 ignore start */
+                    const s = sig === 'SIGHUP' ? this.#hupSig : sig;
+                    if (!ret)
+                        process.kill(process.pid, s);
+                    /* c8 ignore stop */
+                }
+            };
+        }
+        this.#originalProcessReallyExit = process.reallyExit;
+        this.#originalProcessEmit = process.emit;
+    }
+    onExit(cb, opts) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return () => { };
+        }
+        /* c8 ignore stop */
+        if (this.#loaded === false) {
+            this.load();
+        }
+        const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
+        this.#emitter.on(ev, cb);
+        return () => {
+            this.#emitter.removeListener(ev, cb);
+            if (this.#emitter.listeners['exit'].length === 0 &&
+                this.#emitter.listeners['afterExit'].length === 0) {
+                this.unload();
+            }
+        };
+    }
+    load() {
+        if (this.#loaded) {
+            return;
+        }
+        this.#loaded = true;
+        // This is the number of onSignalExit's that are in play.
+        // It's important so that we can count the correct number of
+        // listeners on signals, and don't wait for the other one to
+        // handle it instead of us.
+        this.#emitter.count += 1;
+        for (const sig of signals) {
+            try {
+                const fn = this.#sigListeners[sig];
+                if (fn)
+                    this.#process.on(sig, fn);
+            }
+            catch (_) { }
+        }
+        this.#process.emit = (ev, ...a) => {
+            return this.#processEmit(ev, ...a);
+        };
+        this.#process.reallyExit = (code) => {
+            return this.#processReallyExit(code);
+        };
+    }
+    unload() {
+        if (!this.#loaded) {
+            return;
+        }
+        this.#loaded = false;
+        signals.forEach(sig => {
+            const listener = this.#sigListeners[sig];
+            /* c8 ignore start */
+            if (!listener) {
+                throw new Error('Listener not defined for signal: ' + sig);
+            }
+            /* c8 ignore stop */
+            try {
+                this.#process.removeListener(sig, listener);
+                /* c8 ignore start */
+            }
+            catch (_) { }
+            /* c8 ignore stop */
+        });
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return 0;
+        }
+        this.#process.exitCode = code || 0;
+        /* c8 ignore stop */
+        this.#emitter.emit('exit', this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === 'exit' && processOk(this.#process)) {
+            if (typeof args[0] === 'number') {
+                this.#process.exitCode = args[0];
+                /* c8 ignore start */
+            }
+            /* c8 ignore start */
+            const ret = og.call(this.#process, ev, ...args);
+            /* c8 ignore start */
+            this.#emitter.emit('exit', this.#process.exitCode, null);
+            /* c8 ignore stop */
+            return ret;
+        }
+        else {
+            return og.call(this.#process, ev, ...args);
+        }
+    }
+}
+const process$1 = globalThis.process;
+// wrap so that we call the method on the actual handler, without
+// exporting it directly.
+const { 
+/**
+ * Called when the process is exiting, whether via signal, explicit
+ * exit, or running out of stuff to do.
+ *
+ * If the global process object is not suitable for instrumentation,
+ * then this will be a no-op.
+ *
+ * Returns a function that may be used to unload signal-exit.
+ */
+onExit, 
+/**
+ * Load the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+load, 
+/**
+ * Unload the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+unload, } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+const CLEAR_SCREEN = '\u001Bc';
+function getResetScreen(configs, allowClearScreen) {
+    let clearScreen = allowClearScreen;
+    for (const config of configs) {
+        if (config.watch && config.watch.clearScreen === false) {
+            clearScreen = false;
+        }
+    }
+    if (clearScreen) {
+        return (heading) => rollup.stderr(CLEAR_SCREEN + heading);
+    }
+    let firstRun = true;
+    return (heading) => {
+        if (firstRun) {
+            rollup.stderr(heading);
+            firstRun = false;
+        }
+    };
+}
+
+function extractWatchHooks(command) {
+    if (!Array.isArray(command.watch))
+        return {};
+    return command.watch
+        .filter(value => typeof value === 'object')
+        .reduce((accumulator, keyValueOption) => ({ ...accumulator, ...keyValueOption }), {});
+}
+function createWatchHooks(command) {
+    const watchHooks = extractWatchHooks(command);
+    return function (hook) {
+        if (watchHooks[hook]) {
+            const cmd = watchHooks[hook];
+            if (!command.silent) {
+                rollup.stderr(rollup.cyan$1(`watch.${hook} ${rollup.bold(`$ ${cmd}`)}`));
+            }
+            try {
+                // !! important - use stderr for all writes from execSync
+                const stdio = [process.stdin, process.stderr, process.stderr];
+                node_child_process.execSync(cmd, { stdio: command.silent ? 'ignore' : stdio });
+            }
+            catch (error) {
+                rollup.stderr(error.message);
+            }
+        }
+    };
+}
+
+async function watch(command) {
+    process$2.env.ROLLUP_WATCH = 'true';
+    const isTTY = process$2.stderr.isTTY;
+    const silent = command.silent;
+    let watcher;
+    let configWatcher;
+    let resetScreen;
+    const configFile = command.config ? await cli.getConfigPath(command.config) : null;
+    const runWatchHook = createWatchHooks(command);
+    onExit(close);
+    process$2.on('uncaughtException', closeWithError);
+    if (!process$2.stdin.isTTY) {
+        process$2.stdin.on('end', close);
+        process$2.stdin.resume();
+    }
+    async function loadConfigFromFileAndTrack(configFile) {
+        let configFileData = null;
+        let configFileRevision = 0;
+        configWatcher = index.chokidar.watch(configFile).on('change', reloadConfigFile);
+        await reloadConfigFile();
+        async function reloadConfigFile() {
+            try {
+                const newConfigFileData = await promises.readFile(configFile, 'utf8');
+                if (newConfigFileData === configFileData) {
+                    return;
+                }
+                configFileRevision++;
+                const currentConfigFileRevision = configFileRevision;
+                if (configFileData) {
+                    rollup.stderr(`\nReloading updated config...`);
+                }
+                configFileData = newConfigFileData;
+                const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command, true);
+                if (currentConfigFileRevision !== configFileRevision) {
+                    return;
+                }
+                if (watcher) {
+                    await watcher.close();
+                }
+                start(options, warnings);
+            }
+            catch (error) {
+                rollup.handleError(error, true);
+            }
+        }
+    }
+    if (configFile) {
+        await loadConfigFromFileAndTrack(configFile);
+    }
+    else {
+        const { options, warnings } = await cli.loadConfigFromCommand(command, true);
+        await start(options, warnings);
+    }
+    async function start(configs, warnings) {
+        watcher = rollup_js.watch(configs);
+        watcher.on('event', event => {
+            switch (event.code) {
+                case 'ERROR': {
+                    warnings.flush();
+                    rollup.handleError(event.error, true);
+                    runWatchHook('onError');
+                    break;
+                }
+                case 'START': {
+                    if (!silent) {
+                        if (!resetScreen) {
+                            resetScreen = getResetScreen(configs, isTTY);
+                        }
+                        resetScreen(rollup.underline(`rollup v${rollup.version}`));
+                    }
+                    runWatchHook('onStart');
+                    break;
+                }
+                case 'BUNDLE_START': {
+                    if (!silent) {
+                        let input = event.input;
+                        if (typeof input !== 'string') {
+                            input = Array.isArray(input)
+                                ? input.join(', ')
+                                : Object.values(input).join(', ');
+                        }
+                        rollup.stderr(rollup.cyan$1(`bundles ${rollup.bold(input)} → ${rollup.bold(event.output.map(parseAst_js.relativeId).join(', '))}...`));
+                    }
+                    runWatchHook('onBundleStart');
+                    break;
+                }
+                case 'BUNDLE_END': {
+                    warnings.flush();
+                    if (!silent)
+                        rollup.stderr(rollup.green(`created ${rollup.bold(event.output.map(parseAst_js.relativeId).join(', '))} in ${rollup.bold(cli.prettyMilliseconds(event.duration))}`));
+                    runWatchHook('onBundleEnd');
+                    if (event.result && event.result.getTimings) {
+                        cli.printTimings(event.result.getTimings());
+                    }
+                    break;
+                }
+                case 'END': {
+                    runWatchHook('onEnd');
+                    if (!silent && isTTY) {
+                        rollup.stderr(`\n[${dateTime()}] waiting for changes...`);
+                    }
+                }
+            }
+            if ('result' in event && event.result) {
+                event.result.close().catch(error => rollup.handleError(error, true));
+            }
+        });
+    }
+    async function close(code) {
+        process$2.removeListener('uncaughtException', closeWithError);
+        // removing a non-existent listener is a no-op
+        process$2.stdin.removeListener('end', close);
+        if (watcher)
+            await watcher.close();
+        if (configWatcher)
+            configWatcher.close();
+        if (code)
+            process$2.exit(code);
+    }
+    // return a promise that never resolves to keep the process running
+    return new Promise(() => { });
+}
+function closeWithError(error) {
+    error.name = `Uncaught ${error.name}`;
+    rollup.handleError(error);
+}
+
+exports.watch = watch;
+//# sourceMappingURL=watch-cli.js.map

node_modules/rollup/dist/shared/watch.js

@@ -0,0 +1,323 @@
+/*
+  @license
+	Rollup.js v4.9.6
+	Sun, 21 Jan 2024 05:51:51 GMT - commit ecb6b0a430098052781aa6ee04ec92ee70960321
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const node_path = require('node:path');
+const process = require('node:process');
+const rollup = require('./rollup.js');
+const node_os = require('node:os');
+const index = require('./index.js');
+require('./parseAst.js');
+require('../native.js');
+require('tty');
+require('path');
+require('node:perf_hooks');
+require('node:fs/promises');
+require('fs');
+require('util');
+require('stream');
+require('os');
+require('./fsevents-importer.js');
+require('events');
+
+class FileWatcher {
+    constructor(task, chokidarOptions) {
+        this.transformWatchers = new Map();
+        this.chokidarOptions = chokidarOptions;
+        this.task = task;
+        this.watcher = this.createWatcher(null);
+    }
+    close() {
+        this.watcher.close();
+        for (const watcher of this.transformWatchers.values()) {
+            watcher.close();
+        }
+    }
+    unwatch(id) {
+        this.watcher.unwatch(id);
+        const transformWatcher = this.transformWatchers.get(id);
+        if (transformWatcher) {
+            this.transformWatchers.delete(id);
+            transformWatcher.close();
+        }
+    }
+    watch(id, isTransformDependency) {
+        if (isTransformDependency) {
+            const watcher = this.transformWatchers.get(id) ?? this.createWatcher(id);
+            watcher.add(id);
+            this.transformWatchers.set(id, watcher);
+        }
+        else {
+            this.watcher.add(id);
+        }
+    }
+    createWatcher(transformWatcherId) {
+        const task = this.task;
+        const isLinux = node_os.platform() === 'linux';
+        const isTransformDependency = transformWatcherId !== null;
+        const handleChange = (id, event) => {
+            const changedId = transformWatcherId || id;
+            if (isLinux) {
+                // unwatching and watching fixes an issue with chokidar where on certain systems,
+                // a file that was unlinked and immediately recreated would create a change event
+                // but then no longer any further events
+                watcher.unwatch(changedId);
+                watcher.add(changedId);
+            }
+            task.invalidate(changedId, { event, isTransformDependency });
+        };
+        const watcher = index.chokidar
+            .watch([], this.chokidarOptions)
+            .on('add', id => handleChange(id, 'create'))
+            .on('change', id => handleChange(id, 'update'))
+            .on('unlink', id => handleChange(id, 'delete'));
+        return watcher;
+    }
+}
+
+const eventsRewrites = {
+    create: {
+        create: 'buggy',
+        delete: null, //delete file from map
+        update: 'create'
+    },
+    delete: {
+        create: 'update',
+        delete: 'buggy',
+        update: 'buggy'
+    },
+    update: {
+        create: 'buggy',
+        delete: 'delete',
+        update: 'update'
+    }
+};
+class Watcher {
+    constructor(optionsList, emitter) {
+        this.buildDelay = 0;
+        this.buildTimeout = null;
+        this.closed = false;
+        this.invalidatedIds = new Map();
+        this.rerun = false;
+        this.running = true;
+        this.emitter = emitter;
+        emitter.close = this.close.bind(this);
+        this.tasks = optionsList.map(options => new Task(this, options));
+        for (const { watch } of optionsList) {
+            if (watch && typeof watch.buildDelay === 'number') {
+                this.buildDelay = Math.max(this.buildDelay, watch.buildDelay);
+            }
+        }
+        process.nextTick(() => this.run());
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        for (const task of this.tasks) {
+            task.close();
+        }
+        await this.emitter.emit('close');
+        this.emitter.removeAllListeners();
+    }
+    invalidate(file) {
+        if (file) {
+            const previousEvent = this.invalidatedIds.get(file.id);
+            const event = previousEvent ? eventsRewrites[previousEvent][file.event] : file.event;
+            if (event === 'buggy') {
+                //TODO: throws or warn? Currently just ignore, uses new event
+                this.invalidatedIds.set(file.id, file.event);
+            }
+            else if (event === null) {
+                this.invalidatedIds.delete(file.id);
+            }
+            else {
+                this.invalidatedIds.set(file.id, event);
+            }
+        }
+        if (this.running) {
+            this.rerun = true;
+            return;
+        }
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        this.buildTimeout = setTimeout(async () => {
+            this.buildTimeout = null;
+            try {
+                await Promise.all([...this.invalidatedIds].map(([id, event]) => this.emitter.emit('change', id, { event })));
+                this.invalidatedIds.clear();
+                await this.emitter.emit('restart');
+                this.emitter.removeListenersForCurrentRun();
+                this.run();
+            }
+            catch (error) {
+                this.invalidatedIds.clear();
+                await this.emitter.emit('event', {
+                    code: 'ERROR',
+                    error,
+                    result: null
+                });
+                await this.emitter.emit('event', {
+                    code: 'END'
+                });
+            }
+        }, this.buildDelay);
+    }
+    async run() {
+        this.running = true;
+        await this.emitter.emit('event', {
+            code: 'START'
+        });
+        for (const task of this.tasks) {
+            await task.run();
+        }
+        this.running = false;
+        await this.emitter.emit('event', {
+            code: 'END'
+        });
+        if (this.rerun) {
+            this.rerun = false;
+            this.invalidate();
+        }
+    }
+}
+class Task {
+    constructor(watcher, options) {
+        this.cache = { modules: [] };
+        this.watchFiles = [];
+        this.closed = false;
+        this.invalidated = true;
+        this.watched = new Set();
+        this.watcher = watcher;
+        this.options = options;
+        this.skipWrite = Boolean(options.watch && options.watch.skipWrite);
+        this.outputs = this.options.output;
+        this.outputFiles = this.outputs.map(output => {
+            if (output.file || output.dir)
+                return node_path.resolve(output.file || output.dir);
+            return undefined;
+        });
+        const watchOptions = this.options.watch || {};
+        this.filter = rollup.createFilter(watchOptions.include, watchOptions.exclude);
+        this.fileWatcher = new FileWatcher(this, {
+            ...watchOptions.chokidar,
+            disableGlobbing: true,
+            ignoreInitial: true
+        });
+    }
+    close() {
+        this.closed = true;
+        this.fileWatcher.close();
+    }
+    invalidate(id, details) {
+        this.invalidated = true;
+        if (details.isTransformDependency) {
+            for (const module of this.cache.modules) {
+                if (!module.transformDependencies.includes(id))
+                    continue;
+                // effective invalidation
+                module.originalCode = null;
+            }
+        }
+        this.watcher.invalidate({ event: details.event, id });
+    }
+    async run() {
+        if (!this.invalidated)
+            return;
+        this.invalidated = false;
+        const options = {
+            ...this.options,
+            cache: this.cache
+        };
+        const start = Date.now();
+        await this.watcher.emitter.emit('event', {
+            code: 'BUNDLE_START',
+            input: this.options.input,
+            output: this.outputFiles
+        });
+        let result = null;
+        try {
+            result = await rollup.rollupInternal(options, this.watcher.emitter);
+            if (this.closed) {
+                return;
+            }
+            this.updateWatchedFiles(result);
+            if (!this.skipWrite) {
+                await Promise.all(this.outputs.map(output => result.write(output)));
+                if (this.closed) {
+                    return;
+                }
+                this.updateWatchedFiles(result);
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'BUNDLE_END',
+                duration: Date.now() - start,
+                input: this.options.input,
+                output: this.outputFiles,
+                result
+            });
+        }
+        catch (error) {
+            if (!this.closed) {
+                if (Array.isArray(error.watchFiles)) {
+                    for (const id of error.watchFiles) {
+                        this.watchFile(id);
+                    }
+                }
+                if (error.id) {
+                    this.cache.modules = this.cache.modules.filter(module => module.id !== error.id);
+                }
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'ERROR',
+                error,
+                result
+            });
+        }
+    }
+    updateWatchedFiles(result) {
+        const previouslyWatched = this.watched;
+        this.watched = new Set();
+        this.watchFiles = result.watchFiles;
+        this.cache = result.cache;
+        for (const id of this.watchFiles) {
+            this.watchFile(id);
+        }
+        for (const module of this.cache.modules) {
+            for (const depId of module.transformDependencies) {
+                this.watchFile(depId, true);
+            }
+        }
+        for (const id of previouslyWatched) {
+            if (!this.watched.has(id)) {
+                this.fileWatcher.unwatch(id);
+            }
+        }
+    }
+    watchFile(id, isTransformDependency = false) {
+        if (!this.filter(id))
+            return;
+        this.watched.add(id);
+        if (this.outputFiles.includes(id)) {
+            throw new Error('Cannot import the generated bundle');
+        }
+        // this is necessary to ensure that any 'renamed' files
+        // continue to be watched following an error
+        this.fileWatcher.watch(id, isTransformDependency);
+    }
+}
+
+exports.Task = Task;
+exports.Watcher = Watcher;
+//# sourceMappingURL=watch.js.map