feat: docker compose maybe

node_modules/rollup/dist/es/getLogFilter.js

@@ -0,0 +1,64 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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/rollup.js

@@ -0,0 +1,17 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+export { version as VERSION, defineConfig, rollup, watch } from './shared/node-entry.js';
+import 'node:path';
+import 'path';
+import 'node:process';
+import 'node:perf_hooks';
+import 'node:crypto';
+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 v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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,29 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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');
+const loadConfigFile_js = require('./shared/loadConfigFile.js');
+require('tty');
+require('path');
+require('node:perf_hooks');
+require('node:crypto');
+require('./getLogFilter.js');
+
+
+
+exports.loadConfigFile = loadConfigFile_js.loadConfigFile;
+//# sourceMappingURL=loadConfigFile.js.map

node_modules/rollup/dist/rollup.js

@@ -0,0 +1,31 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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 watchProxy = require('./shared/watch-proxy.js');
+require('node:process');
+require('tty');
+require('node:path');
+require('path');
+require('node:perf_hooks');
+require('node:crypto');
+require('node:fs/promises');
+require('./shared/fsevents-importer.js');
+
+
+
+exports.VERSION = rollup.version;
+exports.defineConfig = rollup.defineConfig;
+exports.rollup = rollup.rollup;
+exports.watch = watchProxy.watch;
+//# sourceMappingURL=rollup.js.map

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

@@ -0,0 +1,37 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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 v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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 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 rollup.LOGLEVEL_WARN: {
+                    return add(log);
+                }
+                case rollup.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 ${rollup.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(rollup.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(rollup.printQuotedStringList(warnings.map(warning => warning.names[0])));
+    },
+    EVAL(warnings) {
+        title('Use of eval is strongly discouraged');
+        info(rollup.getRollupUrl(rollup.URL_AVOIDING_EVAL));
+        showTruncatedWarnings(warnings);
+    },
+    MISSING_EXPORT(warnings) {
+        title('Missing exports');
+        info(rollup.getRollupUrl(rollup.URL_NAME_IS_NOT_EXPORTED));
+        for (const warning of warnings) {
+            rollup.stderr(rollup.bold(rollup.relativeId(warning.id)));
+            rollup.stderr(`${warning.binding} is not exported by ${rollup.relativeId(warning.exporter)}`);
+            rollup.stderr(rollup.gray(warning.frame));
+        }
+    },
+    MISSING_GLOBAL_NAME(warnings) {
+        title(`Missing global variable ${warnings.length > 1 ? 'names' : 'name'}`);
+        info(rollup.getRollupUrl(rollup.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(rollup.getRollupUrl(rollup.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(rollup.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(rollup.relativeId(warning.reexporter))}" re-exports "${warning.binding}" from both "${rollup.relativeId(warning.ids[0])}" and "${rollup.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 = rollup.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(rollup.getRollupUrl(rollup.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 ${rollup.printQuotedStringList(plugins)}) should generate accompanying sourcemaps.`);
+    },
+    THIS_IS_UNDEFINED(warnings) {
+        title('"this" has been rewritten to "undefined"');
+        info(rollup.getRollupUrl(rollup.URL_THIS_IS_UNDEFINED));
+        showTruncatedWarnings(warnings);
+    },
+    UNRESOLVED_IMPORT(warnings) {
+        title('Unresolved dependencies');
+        info(rollup.getRollupUrl(rollup.URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY));
+        const dependencies = new Map();
+        for (const warning of warnings) {
+            rollup.getOrCreate(dependencies, rollup.relativeId(warning.exporter), rollup.getNewArray).push(rollup.relativeId(warning.id));
+        }
+        for (const [dependency, importers] of dependencies) {
+            rollup.stderr(`${rollup.bold(dependency)} (imported by ${rollup.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 ' +
+                rollup.printQuotedStringList(warning.ids.map(rollup.relativeId)) +
+                '.');
+        }
+    }
+};
+function defaultBody(log) {
+    if (log.url) {
+        info(rollup.getRollupUrl(log.url));
+    }
+    const id = log.loc?.file || log.id;
+    if (id) {
+        const loc = log.loc ? `${rollup.relativeId(id)} (${log.loc.line}:${log.loc.column})` : rollup.relativeId(id);
+        rollup.stderr(rollup.bold(rollup.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(rollup.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 rollup.error(rollup.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 rollup.error(rollup.logCannotLoadConfigAsCjs(error_));
+        }
+        if (error_.message.includes('not defined in ES module scope')) {
+            return rollup.error(rollup.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 ${rollup.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 {
+        // Not awaiting here saves some ms while potentially hiding a non-critical error
+        promises.unlink(bundledFileName);
+    }
+}
+async function getConfigList(configFileExport, commandOptions) {
+    const config = await (typeof configFileExport === 'function'
+        ? configFileExport(commandOptions)
+        : configFileExport);
+    if (Object.keys(config).length === 0) {
+        return rollup.error(rollup.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,561 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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 loadConfigFile_js = require('./loadConfigFile.js');
+const node_child_process = require('node:child_process');
+const watchProxy = require('./watch-proxy.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('node:crypto');
+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 = watchProxy.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(rollup.relativeId).join(', '))}...`));
+                    }
+                    runWatchHook('onBundleStart');
+                    break;
+                }
+                case 'BUNDLE_END': {
+                    warnings.flush();
+                    if (!silent)
+                        rollup.stderr(rollup.green(`created ${rollup.bold(event.output.map(rollup.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-proxy.js

@@ -0,0 +1,87 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const rollup = require('./rollup.js');
+const fseventsImporter = require('./fsevents-importer.js');
+
+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 rollup.error(rollup.logInvalidOption('watch', rollup.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('./watch.js'));
+    new Watcher(watchOptionsList, emitter);
+}
+
+exports.watch = watch;
+//# sourceMappingURL=watch-proxy.js.map

node_modules/rollup/dist/shared/watch.js

@@ -0,0 +1,316 @@
+/*
+  @license
+	Rollup.js v3.29.4
+	Thu, 28 Sep 2023 04:54:30 GMT - commit 4e92d60fa90cead39481e3703d26e5d812f43bd1
+
+	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('tty');
+require('path');
+require('node:perf_hooks');
+require('node:crypto');
+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,
+        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);
+            this.skipWrite || (await Promise.all(this.outputs.map(output => result.write(output))));
+            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