condenser 0.0.5 → 0.0.7

data/lib/condenser/processors/node_modules/rollup/README.md

@@ -1,35 +1,29 @@
 # Rollup
 
 <p align="center">
-  <a href="https://travis-ci.org/rollup/rollup">
-    <img src="https://api.travis-ci.org/rollup/rollup.svg?branch=master"
-         alt="build status">
-  </a>
   <a href="https://www.npmjs.com/package/rollup">
-    <img src="https://img.shields.io/npm/v/rollup.svg"
-         alt="npm version">
+    <img src="https://img.shields.io/npm/v/rollup.svg" alt="npm version" >
   </a>
   <a href="https://packagephobia.now.sh/result?p=rollup">
-    <img src="https://packagephobia.now.sh/badge?p=rollup"
-         alt="install size">
+    <img src="https://packagephobia.now.sh/badge?p=rollup" alt="install size" >
+  </a>
+  <a href="https://codecov.io/gh/rollup/rollup">
+    <img src="https://codecov.io/gh/rollup/rollup/graph/badge.svg" alt="code coverage" >
   </a>
-    <a href="#backers" alt="sponsors on Open Collective">
-      <img src="https://opencollective.com/rollup/backers/badge.svg" />
+  <a href="#backers" alt="sponsors on Open Collective">
+      <img src="https://opencollective.com/rollup/backers/badge.svg" alt="backers" >
   </a> 
   <a href="#sponsors" alt="Sponsors on Open Collective">
-    <img src="https://opencollective.com/rollup/sponsors/badge.svg" />
+    <img src="https://opencollective.com/rollup/sponsors/badge.svg" alt="sponsors" >
   </a> 
   <a href="https://github.com/rollup/rollup/blob/master/LICENSE.md">
-    <img src="https://img.shields.io/npm/l/rollup.svg"
-         alt="license">
+    <img src="https://img.shields.io/npm/l/rollup.svg" alt="license">
   </a>
   <a href="https://david-dm.org/rollup/rollup">
-    <img src="https://david-dm.org/rollup/rollup/status.svg"
-         alt="dependency status">
+    <img src="https://david-dm.org/rollup/rollup/status.svg" alt="dependency status">
   </a>
   <a href='https://gitter.im/rollup/rollup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge'>
-    <img src='https://badges.gitter.im/rollup/rollup.svg'
-         alt='Join the chat at https://gitter.im/rollup/rollup'>
+    <img src='https://badges.gitter.im/rollup/rollup.svg' alt='Join the chat at https://gitter.im/rollup/rollup'>
   </a>
 </p>
 
@@ -40,7 +34,7 @@ Rollup is a module bundler for JavaScript which compiles small pieces of code in
 
 ## Quick Start Guide
 
-Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/#command-line-reference) with an optional configuration file, or else through its [JavaScript API](https://rollupjs.org/#javascript-api). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](http://rollupjs.org/).
+Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/#command-line-reference) with an optional configuration file, or else through its [JavaScript API](https://rollupjs.org/#javascript-api). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](https://rollupjs.org/).
 
 ### Commands
 

data/lib/condenser/processors/node_modules/rollup/dist/bin/rollup

@@ -0,0 +1,1365 @@
+#!/usr/bin/env node
+
+/*
+  @license
+	Rollup.js v1.20.2
+	Sun, 25 Aug 2019 05:31:46 GMT - commit b1747e49d9659799a8c128d3052e5e5703362c37
+
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+var rollup_js = require('../rollup.js');
+var index = require('../shared/index.js');
+require('util');
+var path = require('path');
+var fs = require('fs');
+require('acorn');
+var events = require('events');
+require('module');
+var assert = require('assert');
+
+var help = "rollup version __VERSION__\n=====================================\n\nUsage: rollup [options] <entry file>\n\nBasic options:\n\n-c, --config <filename>     Use this config file (if argument is used but value\n                              is unspecified, defaults to rollup.config.js)\n-d, --dir <dirname>         Directory for chunks (if absent, prints to stdout)\n-e, --external <ids>        Comma-separate list of module IDs to exclude\n-f, --format <format>       Type of output (amd, cjs, esm, iife, umd)\n-g, --globals <pairs>       Comma-separate list of `moduleID:Global` pairs\n-h, --help                  Show this help message\n-i, --input <filename>      Input (alternative to <entry file>)\n-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)\n-n, --name <name>           Name for UMD export\n-o, --file <output>         Single output file (if absent, prints to stdout)\n-v, --version               Show version number\n-w, --watch                 Watch files in bundle and rebuild on changes\n--amd.id <id>               ID for AMD module (default is anonymous)\n--amd.define <name>         Function to use in place of `define`\n--assetFileNames <pattern>  Name pattern for emitted assets\n--banner <text>             Code to insert at top of bundle (outside wrapper)\n--chunkFileNames <pattern>  Name pattern for emitted secondary chunks\n--compact                   Minify wrapper code\n--context <variable>        Specify top-level `this` value\n--dynamicImportFunction <name>         Rename the dynamic `import()` function\n--entryFileNames <pattern>  Name pattern for emitted entry chunks\n--environment <values>      Settings passed to config file (see example)\n--no-esModule               Do not add __esModule property\n--exports <mode>            Specify export mode (auto, default, named, none)\n--extend                    Extend global variable defined by --name\n--footer <text>             Code to insert at end of bundle (outside wrapper)\n--no-freeze                 Do not freeze namespace objects\n--no-indent                 Don't indent result\n--no-interop                Do not include interop block\n--inlineDynamicImports      Create single bundle when using dynamic imports\n--intro <text>              Code to insert at top of bundle (inside wrapper)\n--namespaceToStringTag      Create proper `.toString` methods for namespaces\n--noConflict                Generate a noConflict method for UMD globals\n--no-strict                 Don't emit `\"use strict\";` in the generated modules\n--outro <text>              Code to insert at end of bundle (inside wrapper)\n--preferConst               Use `const` instead of `var` for exports\n--preserveModules           Preserve module structure\n--preserveSymlinks          Do not follow symlinks when resolving files\n--shimMissingExports        Create shim variables for missing exports\n--silent                    Don't print warnings\n--sourcemapExcludeSources   Do not include source code in source maps\n--sourcemapFile <file>      Specify bundle position for source maps\n--strictDeprecations        Throw errors for deprecated features\n--no-treeshake              Disable tree-shaking optimisations\n--no-treeshake.annotations  Ignore pure call annotations\n--no-treeshake.propertyReadSideEffects Ignore property access side-effects\n--treeshake.pureExternalModules        Assume side-effect free externals\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n  -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n";
+
+var minimist = function (args, opts) {
+    if (!opts)
+        opts = {};
+    var flags = { bools: {}, strings: {}, unknownFn: null };
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+        flags.allBools = true;
+    }
+    else {
+        [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+            flags.bools[key] = true;
+        });
+    }
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+    });
+    var defaults = opts['default'] || {};
+    var argv = { _: [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    var notFlags = [];
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--') + 1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+    function setArg(key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false)
+                return;
+        }
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val;
+        setKey(argv, key.split('.'), value);
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+    function setKey(obj, keys, value) {
+        var o = obj;
+        keys.slice(0, -1).forEach(function (key) {
+            if (o[key] === undefined)
+                o[key] = {};
+            o = o[key];
+        });
+        var key = keys[keys.length - 1];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [o[key], value];
+        }
+    }
+    function aliasIsBoolean(key) {
+        return aliases[key].some(function (x) {
+            return flags.bools[x];
+        });
+    }
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+                && !flags.bools[key]
+                && !flags.allBools
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1, -1).split('');
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j + 2);
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                if (/[A-Za-z]/.test(letters[j])
+                    && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j + 2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1])
+                    && !flags.bools[key]
+                    && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i + 1], arg);
+                    i++;
+                }
+                else if (args[i + 1] && /true|false/.test(args[i + 1])) {
+                    setArg(key, args[i + 1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(flags.strings['_'] || !isNumber(arg) ? arg : Number(arg));
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function (key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function (key) {
+            argv._.push(key);
+        });
+    }
+    return argv;
+};
+function hasKey(obj, keys) {
+    var o = obj;
+    keys.slice(0, -1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+function isNumber(x) {
+    if (typeof x === 'number')
+        return true;
+    if (/^0x[0-9a-f]+$/i.test(x))
+        return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+const tc = {
+    enabled: process.env.FORCE_COLOR ||
+        process.platform === "win32" ||
+        (process.stdout.isTTY && process.env.TERM && process.env.TERM !== "dumb")
+};
+const Styles = (tc.Styles = {});
+const defineProp = Object.defineProperty;
+const init = (style, open, close, re) => {
+    let i, len = 1, seq = [(Styles[style] = { open, close, re })];
+    const fn = s => {
+        if (tc.enabled) {
+            for (i = 0, s += ""; i < len; i++) {
+                style = seq[i];
+                s =
+                    (open = style.open) +
+                        (~s.indexOf((close = style.close), 4) // skip first \x1b[
+                            ? s.replace(style.re, open)
+                            : s) +
+                        close;
+            }
+            len = 1;
+        }
+        return s;
+    };
+    defineProp(tc, style, {
+        get: () => {
+            for (let k in Styles)
+                defineProp(fn, k, {
+                    get: () => ((seq[len++] = Styles[k]), fn)
+                });
+            delete tc[style];
+            return (tc[style] = fn);
+        },
+        configurable: true
+    });
+};
+init("reset", "\x1b[0m", "\x1b[0m", /\x1b\[0m/g);
+init("bold", "\x1b[1m", "\x1b[22m", /\x1b\[22m/g);
+init("dim", "\x1b[2m", "\x1b[22m", /\x1b\[22m/g);
+init("italic", "\x1b[3m", "\x1b[23m", /\x1b\[23m/g);
+init("underline", "\x1b[4m", "\x1b[24m", /\x1b\[24m/g);
+init("inverse", "\x1b[7m", "\x1b[27m", /\x1b\[27m/g);
+init("hidden", "\x1b[8m", "\x1b[28m", /\x1b\[28m/g);
+init("strikethrough", "\x1b[9m", "\x1b[29m", /\x1b\[29m/g);
+init("black", "\x1b[30m", "\x1b[39m", /\x1b\[39m/g);
+init("red", "\x1b[31m", "\x1b[39m", /\x1b\[39m/g);
+init("green", "\x1b[32m", "\x1b[39m", /\x1b\[39m/g);
+init("yellow", "\x1b[33m", "\x1b[39m", /\x1b\[39m/g);
+init("blue", "\x1b[34m", "\x1b[39m", /\x1b\[39m/g);
+init("magenta", "\x1b[35m", "\x1b[39m", /\x1b\[39m/g);
+init("cyan", "\x1b[36m", "\x1b[39m", /\x1b\[39m/g);
+init("white", "\x1b[37m", "\x1b[39m", /\x1b\[39m/g);
+init("gray", "\x1b[90m", "\x1b[39m", /\x1b\[39m/g);
+init("bgBlack", "\x1b[40m", "\x1b[49m", /\x1b\[49m/g);
+init("bgRed", "\x1b[41m", "\x1b[49m", /\x1b\[49m/g);
+init("bgGreen", "\x1b[42m", "\x1b[49m", /\x1b\[49m/g);
+init("bgYellow", "\x1b[43m", "\x1b[49m", /\x1b\[49m/g);
+init("bgBlue", "\x1b[44m", "\x1b[49m", /\x1b\[49m/g);
+init("bgMagenta", "\x1b[45m", "\x1b[49m", /\x1b\[49m/g);
+init("bgCyan", "\x1b[46m", "\x1b[49m", /\x1b\[49m/g);
+init("bgWhite", "\x1b[47m", "\x1b[49m", /\x1b\[49m/g);
+var turbocolor = tc;
+
+// log to stderr to keep `rollup main.js > bundle.js` from breaking
+const stderr = console.error.bind(console);
+function handleError(err, recover = false) {
+    let description = err.message || err;
+    if (err.name)
+        description = `${err.name}: ${description}`;
+    const message = (err.plugin
+        ? `(plugin ${err.plugin}) ${description}`
+        : description) || err;
+    stderr(turbocolor.bold.red(`[!] ${turbocolor.bold(message.toString())}`));
+    if (err.url) {
+        stderr(turbocolor.cyan(err.url));
+    }
+    if (err.loc) {
+        stderr(`${index.relativeId((err.loc.file || err.id))} (${err.loc.line}:${err.loc.column})`);
+    }
+    else if (err.id) {
+        stderr(index.relativeId(err.id));
+    }
+    if (err.frame) {
+        stderr(turbocolor.dim(err.frame));
+    }
+    if (err.stack) {
+        stderr(turbocolor.dim(err.stack));
+    }
+    stderr('');
+    if (!recover)
+        process.exit(1);
+}
+
+function batchWarnings() {
+    let allWarnings = new Map();
+    let count = 0;
+    return {
+        get count() {
+            return count;
+        },
+        add: (warning) => {
+            if (typeof warning === 'string') {
+                warning = { code: 'UNKNOWN', message: warning };
+            }
+            if (warning.code in immediateHandlers) {
+                immediateHandlers[warning.code](warning);
+                return;
+            }
+            if (!allWarnings.has(warning.code))
+                allWarnings.set(warning.code, []);
+            allWarnings.get(warning.code).push(warning);
+            count += 1;
+        },
+        flush: () => {
+            if (count === 0)
+                return;
+            const codes = Array.from(allWarnings.keys()).sort((a, b) => {
+                if (deferredHandlers[a] && deferredHandlers[b]) {
+                    return deferredHandlers[a].priority - deferredHandlers[b].priority;
+                }
+                if (deferredHandlers[a])
+                    return -1;
+                if (deferredHandlers[b])
+                    return 1;
+                return (allWarnings.get(b).length -
+                    allWarnings.get(a).length);
+            });
+            codes.forEach(code => {
+                const handler = deferredHandlers[code];
+                const warnings = allWarnings.get(code);
+                if (handler) {
+                    handler.fn(warnings);
+                }
+                else {
+                    warnings.forEach(warning => {
+                        title(warning.message);
+                        if (warning.url)
+                            info(warning.url);
+                        const id = (warning.loc && warning.loc.file) || warning.id;
+                        if (id) {
+                            const loc = warning.loc
+                                ? `${index.relativeId(id)}: (${warning.loc.line}:${warning.loc.column})`
+                                : index.relativeId(id);
+                            stderr(turbocolor.bold(index.relativeId(loc)));
+                        }
+                        if (warning.frame)
+                            info(warning.frame);
+                    });
+                }
+            });
+            allWarnings = new Map();
+            count = 0;
+        }
+    };
+}
+const immediateHandlers = {
+    UNKNOWN_OPTION: warning => {
+        title(`You have passed an unrecognized option`);
+        stderr(warning.message);
+    },
+    MISSING_NODE_BUILTINS: warning => {
+        title(`Missing shims for Node.js built-ins`);
+        const detail = warning.modules.length === 1
+            ? `'${warning.modules[0]}'`
+            : `${warning.modules
+                .slice(0, -1)
+                .map((name) => `'${name}'`)
+                .join(', ')} and '${warning.modules.slice(-1)}'`;
+        stderr(`Creating a browser bundle that depends on ${detail}. You might need to include https://www.npmjs.com/package/rollup-plugin-node-builtins`);
+    },
+    MIXED_EXPORTS: () => {
+        title('Mixing named and default exports');
+        stderr(`Consumers of your bundle will have to use bundle['default'] to access the default export, which may not be what you want. Use \`output.exports: 'named'\` to disable this warning`);
+    },
+    EMPTY_BUNDLE: () => {
+        title(`Generated an empty bundle`);
+    }
+};
+// TODO select sensible priorities
+const deferredHandlers = {
+    UNUSED_EXTERNAL_IMPORT: {
+        fn: warnings => {
+            title('Unused external imports');
+            warnings.forEach(warning => {
+                stderr(`${warning.names} imported from external module '${warning.source}' but never used`);
+            });
+        },
+        priority: 1
+    },
+    UNRESOLVED_IMPORT: {
+        fn: warnings => {
+            title('Unresolved dependencies');
+            info('https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency');
+            const dependencies = new Map();
+            warnings.forEach(warning => {
+                if (!dependencies.has(warning.source))
+                    dependencies.set(warning.source, []);
+                dependencies.get(warning.source).push(warning.importer);
+            });
+            Array.from(dependencies.keys()).forEach(dependency => {
+                const importers = dependencies.get(dependency);
+                stderr(`${turbocolor.bold(dependency)} (imported by ${importers.join(', ')})`);
+            });
+        },
+        priority: 1
+    },
+    MISSING_EXPORT: {
+        fn: warnings => {
+            title('Missing exports');
+            info('https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module');
+            warnings.forEach(warning => {
+                stderr(turbocolor.bold(warning.importer));
+                stderr(`${warning.missing} is not exported by ${warning.exporter}`);
+                stderr(turbocolor.gray(warning.frame));
+            });
+        },
+        priority: 1
+    },
+    THIS_IS_UNDEFINED: {
+        fn: warnings => {
+            title('`this` has been rewritten to `undefined`');
+            info('https://rollupjs.org/guide/en/#error-this-is-undefined');
+            showTruncatedWarnings(warnings);
+        },
+        priority: 1
+    },
+    EVAL: {
+        fn: warnings => {
+            title('Use of eval is strongly discouraged');
+            info('https://rollupjs.org/guide/en/#avoiding-eval');
+            showTruncatedWarnings(warnings);
+        },
+        priority: 1
+    },
+    NON_EXISTENT_EXPORT: {
+        fn: warnings => {
+            title(`Import of non-existent ${warnings.length > 1 ? 'exports' : 'export'}`);
+            showTruncatedWarnings(warnings);
+        },
+        priority: 1
+    },
+    NAMESPACE_CONFLICT: {
+        fn: warnings => {
+            title(`Conflicting re-exports`);
+            warnings.forEach(warning => {
+                stderr(`${turbocolor.bold(index.relativeId(warning.reexporter))} re-exports '${warning.name}' from both ${index.relativeId(warning.sources[0])} and ${index.relativeId(warning.sources[1])} (will be ignored)`);
+            });
+        },
+        priority: 1
+    },
+    MISSING_GLOBAL_NAME: {
+        fn: warnings => {
+            title(`Missing global variable ${warnings.length > 1 ? 'names' : 'name'}`);
+            stderr(`Use output.globals to specify browser global variable names corresponding to external modules`);
+            warnings.forEach(warning => {
+                stderr(`${turbocolor.bold(warning.source)} (guessing '${warning.guess}')`);
+            });
+        },
+        priority: 1
+    },
+    SOURCEMAP_BROKEN: {
+        fn: warnings => {
+            title(`Broken sourcemap`);
+            info('https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect');
+            const plugins = Array.from(new Set(warnings.map(w => w.plugin).filter(Boolean)));
+            const detail = plugins.length === 0
+                ? ''
+                : plugins.length > 1
+                    ? ` (such as ${plugins
+                        .slice(0, -1)
+                        .map(p => `'${p}'`)
+                        .join(', ')} and '${plugins.slice(-1)}')`
+                    : ` (such as '${plugins[0]}')`;
+            stderr(`Plugins that transform code${detail} should generate accompanying sourcemaps`);
+        },
+        priority: 1
+    },
+    PLUGIN_WARNING: {
+        fn: warnings => {
+            const nestedByPlugin = nest(warnings, 'plugin');
+            nestedByPlugin.forEach(({ key: plugin, items }) => {
+                const nestedByMessage = nest(items, 'message');
+                let lastUrl;
+                nestedByMessage.forEach(({ key: message, items }) => {
+                    title(`Plugin ${plugin}: ${message}`);
+                    items.forEach(warning => {
+                        if (warning.url !== lastUrl)
+                            info((lastUrl = warning.url));
+                        if (warning.id) {
+                            let loc = index.relativeId(warning.id);
+                            if (warning.loc) {
+                                loc += `: (${warning.loc.line}:${warning.loc.column})`;
+                            }
+                            stderr(turbocolor.bold(loc));
+                        }
+                        if (warning.frame)
+                            info(warning.frame);
+                    });
+                });
+            });
+        },
+        priority: 1
+    }
+};
+function title(str) {
+    stderr(`${turbocolor.bold.yellow('(!)')} ${turbocolor.bold.yellow(str)}`);
+}
+function info(url) {
+    stderr(turbocolor.gray(url));
+}
+function nest(array, prop) {
+    const nested = [];
+    const lookup = new Map();
+    array.forEach(item => {
+        const key = item[prop];
+        if (!lookup.has(key)) {
+            lookup.set(key, {
+                items: [],
+                key
+            });
+            nested.push(lookup.get(key));
+        }
+        lookup.get(key).items.push(item);
+    });
+    return nested;
+}
+function showTruncatedWarnings(warnings) {
+    const nestedByModule = nest(warnings, 'id');
+    const sliced = nestedByModule.length > 5 ? nestedByModule.slice(0, 3) : nestedByModule;
+    sliced.forEach(({ key: id, items }) => {
+        stderr(turbocolor.bold(index.relativeId(id)));
+        stderr(turbocolor.gray(items[0].frame));
+        if (items.length > 1) {
+            stderr(`...and ${items.length - 1} other ${items.length > 2 ? 'occurrences' : 'occurrence'}`);
+        }
+    });
+    if (nestedByModule.length > sliced.length) {
+        stderr(`\n...and ${nestedByModule.length - sliced.length} other files`);
+    }
+}
+
+var parseMs = milliseconds => {
+    if (typeof milliseconds !== 'number') {
+        throw new TypeError('Expected a number');
+    }
+    const roundTowardsZero = milliseconds > 0 ? Math.floor : Math.ceil;
+    return {
+        days: roundTowardsZero(milliseconds / 86400000),
+        hours: roundTowardsZero(milliseconds / 3600000) % 24,
+        minutes: roundTowardsZero(milliseconds / 60000) % 60,
+        seconds: roundTowardsZero(milliseconds / 1000) % 60,
+        milliseconds: roundTowardsZero(milliseconds) % 1000,
+        microseconds: roundTowardsZero(milliseconds * 1000) % 1000,
+        nanoseconds: roundTowardsZero(milliseconds * 1e6) % 1000
+    };
+};
+
+const pluralize = (word, count) => count === 1 ? word : word + 's';
+var prettyMs = (milliseconds, options = {}) => {
+    if (!Number.isFinite(milliseconds)) {
+        throw new TypeError('Expected a finite number');
+    }
+    if (options.compact) {
+        options.secondsDecimalDigits = 0;
+        options.millisecondsDecimalDigits = 0;
+    }
+    const result = [];
+    const add = (value, long, short, valueString) => {
+        if (value === 0) {
+            return;
+        }
+        const postfix = options.verbose ? ' ' + pluralize(long, value) : short;
+        result.push((valueString || value) + postfix);
+    };
+    const secondsDecimalDigits = typeof options.secondsDecimalDigits === 'number' ?
+        options.secondsDecimalDigits :
+        1;
+    if (secondsDecimalDigits < 1) {
+        const difference = 1000 - (milliseconds % 1000);
+        if (difference < 500) {
+            milliseconds += difference;
+        }
+    }
+    const parsed = parseMs(milliseconds);
+    add(Math.trunc(parsed.days / 365), 'year', 'y');
+    add(parsed.days % 365, 'day', 'd');
+    add(parsed.hours, 'hour', 'h');
+    add(parsed.minutes, 'minute', 'm');
+    if (options.separateMilliseconds ||
+        options.formatSubMilliseconds ||
+        milliseconds < 1000) {
+        add(parsed.seconds, 'second', 's');
+        if (options.formatSubMilliseconds) {
+            add(parsed.milliseconds, 'millisecond', 'ms');
+            add(parsed.microseconds, 'microsecond', 'µs');
+            add(parsed.nanoseconds, 'nanosecond', 'ns');
+        }
+        else {
+            const millisecondsAndBelow = parsed.milliseconds +
+                (parsed.microseconds / 1000) +
+                (parsed.nanoseconds / 1e6);
+            const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === 'number' ?
+                options.millisecondsDecimalDigits :
+                0;
+            const millisecondsString = millisecondsDecimalDigits ?
+                millisecondsAndBelow.toFixed(millisecondsDecimalDigits) :
+                Math.ceil(millisecondsAndBelow);
+            add(parseFloat(millisecondsString, 10), 'millisecond', 'ms', millisecondsString);
+        }
+    }
+    else {
+        const seconds = (milliseconds / 1000) % 60;
+        const secondsDecimalDigits = typeof options.secondsDecimalDigits === 'number' ?
+            options.secondsDecimalDigits :
+            1;
+        const secondsFixed = seconds.toFixed(secondsDecimalDigits);
+        const secondsString = options.keepDecimalsOnWholeSeconds ?
+            secondsFixed :
+            secondsFixed.replace(/\.0+$/, '');
+        add(parseFloat(secondsString, 10), 'second', 's', secondsString);
+    }
+    if (result.length === 0) {
+        return '0' + (options.verbose ? ' milliseconds' : 'ms');
+    }
+    if (options.compact) {
+        return '~' + result[0];
+    }
+    if (typeof options.unitCount === 'number') {
+        return '~' + result.slice(0, Math.max(options.unitCount, 1)).join(' ');
+    }
+    return result.join(' ');
+};
+
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+var SOURCEMAPPING_URL$1 = SOURCEMAPPING_URL;
+
+const BYTE_UNITS = [
+    'B',
+    'kB',
+    'MB',
+    'GB',
+    'TB',
+    'PB',
+    'EB',
+    'ZB',
+    'YB'
+];
+const BIT_UNITS = [
+    'b',
+    'kbit',
+    'Mbit',
+    'Gbit',
+    'Tbit',
+    'Pbit',
+    'Ebit',
+    'Zbit',
+    'Ybit'
+];
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale) => {
+    let result = number;
+    if (typeof locale === 'string') {
+        result = number.toLocaleString(locale);
+    }
+    else if (locale === true) {
+        result = number.toLocaleString();
+    }
+    return result;
+};
+var prettyBytes = (number, options) => {
+    if (!Number.isFinite(number)) {
+        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+    }
+    options = Object.assign({ bits: false }, options);
+    const UNITS = options.bits ? BIT_UNITS : BYTE_UNITS;
+    if (options.signed && number === 0) {
+        return ' 0 ' + UNITS[0];
+    }
+    const isNegative = number < 0;
+    const prefix = isNegative ? '-' : (options.signed ? '+' : '');
+    if (isNegative) {
+        number = -number;
+    }
+    if (number < 1) {
+        const numberString = toLocaleString(number, options.locale);
+        return prefix + numberString + ' ' + UNITS[0];
+    }
+    const exponent = Math.min(Math.floor(Math.log10(number) / 3), UNITS.length - 1);
+    // eslint-disable-next-line unicorn/prefer-exponentiation-operator
+    number = Number((number / Math.pow(1000, exponent)).toPrecision(3));
+    const numberString = toLocaleString(number, options.locale);
+    const unit = UNITS[exponent];
+    return prefix + numberString + ' ' + unit;
+};
+
+function printTimings(timings) {
+    Object.keys(timings).forEach(label => {
+        const color = label[0] === '#' ? (label[1] !== '#' ? turbocolor.underline : turbocolor.bold) : (text) => text;
+        const [time, memory, total] = timings[label];
+        const row = `${label}: ${time.toFixed(0)}ms, ${prettyBytes(memory)} / ${prettyBytes(total)}`;
+        console.info(color(row));
+    });
+}
+
+function build(inputOptions, outputOptions, warnings, silent = false) {
+    const useStdout = !outputOptions[0].file && !outputOptions[0].dir;
+    const start = Date.now();
+    const files = useStdout
+        ? ['stdout']
+        : outputOptions.map(t => index.relativeId(t.file || t.dir));
+    if (!silent) {
+        let inputFiles = undefined;
+        if (typeof inputOptions.input === 'string') {
+            inputFiles = inputOptions.input;
+        }
+        else if (inputOptions.input instanceof Array) {
+            inputFiles = inputOptions.input.join(', ');
+        }
+        else if (typeof inputOptions.input === 'object' && inputOptions.input !== null) {
+            inputFiles = Object.keys(inputOptions.input)
+                .map(name => inputOptions.input[name])
+                .join(', ');
+        }
+        stderr(turbocolor.cyan(`\n${turbocolor.bold(inputFiles)} → ${turbocolor.bold(files.join(', '))}...`));
+    }
+    return rollup_js.rollup(inputOptions)
+        .then((bundle) => {
+        if (useStdout) {
+            const output = outputOptions[0];
+            if (output.sourcemap && output.sourcemap !== 'inline') {
+                handleError({
+                    code: 'MISSING_OUTPUT_OPTION',
+                    message: 'You must specify a --file (-o) option when creating a file with a sourcemap'
+                });
+            }
+            return bundle.generate(output).then(({ output: outputs }) => {
+                for (const file of outputs) {
+                    let source;
+                    if (file.isAsset) {
+                        source = file.source;
+                    }
+                    else {
+                        source = file.code;
+                        if (output.sourcemap === 'inline') {
+                            source += `\n//# ${SOURCEMAPPING_URL$1}=${file
+                                .map.toUrl()}\n`;
+                        }
+                    }
+                    if (outputs.length > 1)
+                        process.stdout.write('\n' + turbocolor.cyan(turbocolor.bold('//→ ' + file.fileName + ':')) + '\n');
+                    process.stdout.write(source);
+                }
+                return null;
+            });
+        }
+        return Promise.all(outputOptions.map(output => bundle.write(output))).then(() => bundle);
+    })
+        .then((bundle) => {
+        if (!silent) {
+            warnings.flush();
+            stderr(turbocolor.green(`created ${turbocolor.bold(files.join(', '))} in ${turbocolor.bold(prettyMs(Date.now() - start))}`));
+            if (bundle && bundle.getTimings) {
+                printTimings(bundle.getTimings());
+            }
+        }
+    })
+        .catch((err) => {
+        if (warnings.count > 0)
+            warnings.flush();
+        handleError(err);
+    });
+}
+
+function loadConfigFile(configFile, commandOptions = {}) {
+    const silent = commandOptions.silent || false;
+    const warnings = batchWarnings();
+    return rollup_js.rollup({
+        external: (id) => (id[0] !== '.' && !path.isAbsolute(id)) || id.slice(-5, id.length) === '.json',
+        input: configFile,
+        onwarn: warnings.add,
+        treeshake: false
+    })
+        .then((bundle) => {
+        if (!silent && warnings.count > 0) {
+            stderr(turbocolor.bold(`loaded ${index.relativeId(configFile)} with warnings`));
+            warnings.flush();
+        }
+        return bundle.generate({
+            exports: 'named',
+            format: 'cjs'
+        });
+    })
+        .then(({ output: [{ code }] }) => {
+        // temporarily override require
+        const defaultLoader = require.extensions['.js'];
+        require.extensions['.js'] = (module, filename) => {
+            if (filename === configFile) {
+                module._compile(code, filename);
+            }
+            else {
+                defaultLoader(module, filename);
+            }
+        };
+        delete require.cache[configFile];
+        return Promise.resolve(require(configFile))
+            .then(configFileContent => {
+            if (configFileContent.default)
+                configFileContent = configFileContent.default;
+            if (typeof configFileContent === 'function') {
+                return configFileContent(commandOptions);
+            }
+            return configFileContent;
+        })
+            .then(configs => {
+            if (Object.keys(configs).length === 0) {
+                handleError({
+                    code: 'MISSING_CONFIG',
+                    message: 'Config file must export an options object, or an array of options objects',
+                    url: 'https://rollupjs.org/guide/en/#configuration-files'
+                });
+            }
+            require.extensions['.js'] = defaultLoader;
+            return Array.isArray(configs) ? configs : [configs];
+        });
+    });
+}
+
+var timeZone = date => {
+    const offset = (date || new 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;
+};
+
+const dateTime = options => {
+    options = Object.assign({
+        date: new Date(),
+        local: true,
+        showTimeZone: false,
+        showMilliseconds: false
+    }, options);
+    let { date } = options;
+    if (options.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 (options.showTimeZone) {
+        end = ' UTC' + (options.local ? timeZone(date) : '');
+    }
+    if (options.showMilliseconds && date.getUTCMilliseconds() > 0) {
+        end = ` ${date.getUTCMilliseconds()}ms${end}`;
+    }
+    return date
+        .toISOString()
+        .replace(/T/, ' ')
+        .replace(/\..+/, end);
+};
+var dateTime_1 = dateTime;
+// TODO: Remove this for the next major release
+var default_1 = dateTime;
+dateTime_1.default = default_1;
+
+var signals = index.createCommonjsModule(function (module) {
+    // 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.
+    //
+    // 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.
+    module.exports = [
+        'SIGABRT',
+        'SIGALRM',
+        'SIGHUP',
+        'SIGINT',
+        'SIGTERM'
+    ];
+    if (process.platform !== 'win32') {
+        module.exports.push('SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+        );
+    }
+    if (process.platform === 'linux') {
+        module.exports.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT', 'SIGUNUSED');
+    }
+});
+
+// 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.
+var signals$1 = signals;
+var EE = events;
+/* istanbul ignore if */
+if (typeof EE !== 'function') {
+    EE = EE.EventEmitter;
+}
+var emitter;
+if (process.__signal_exit_emitter__) {
+    emitter = process.__signal_exit_emitter__;
+}
+else {
+    emitter = process.__signal_exit_emitter__ = new EE();
+    emitter.count = 0;
+    emitter.emitted = {};
+}
+// Because this emitter is a global, we have to check to see if a
+// previous version of this library failed to enable infinite listeners.
+// I know what you're about to say.  But literally everything about
+// signal-exit is a compromise with evil.  Get used to it.
+if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity);
+    emitter.infinite = true;
+}
+var signalExit = function (cb, opts) {
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+    if (loaded === false) {
+        load();
+    }
+    var ev = 'exit';
+    if (opts && opts.alwaysLast) {
+        ev = 'afterexit';
+    }
+    var remove = function () {
+        emitter.removeListener(ev, cb);
+        if (emitter.listeners('exit').length === 0 &&
+            emitter.listeners('afterexit').length === 0) {
+            unload();
+        }
+    };
+    emitter.on(ev, cb);
+    return remove;
+};
+var unload_1 = unload;
+function unload() {
+    if (!loaded) {
+        return;
+    }
+    loaded = false;
+    signals$1.forEach(function (sig) {
+        try {
+            process.removeListener(sig, sigListeners[sig]);
+        }
+        catch (er) { }
+    });
+    process.emit = originalProcessEmit;
+    process.reallyExit = originalProcessReallyExit;
+    emitter.count -= 1;
+}
+function emit(event, code, signal) {
+    if (emitter.emitted[event]) {
+        return;
+    }
+    emitter.emitted[event] = true;
+    emitter.emit(event, code, signal);
+}
+// { <signal>: <listener fn>, ... }
+var sigListeners = {};
+signals$1.forEach(function (sig) {
+    sigListeners[sig] = function listener() {
+        // 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.
+        var listeners = process.listeners(sig);
+        if (listeners.length === emitter.count) {
+            unload();
+            emit('exit', null, sig);
+            /* istanbul ignore next */
+            emit('afterexit', null, sig);
+            /* istanbul ignore next */
+            process.kill(process.pid, sig);
+        }
+    };
+});
+var signals_1 = function () {
+    return signals$1;
+};
+var load_1 = load;
+var loaded = false;
+function load() {
+    if (loaded) {
+        return;
+    }
+    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.
+    emitter.count += 1;
+    signals$1 = signals$1.filter(function (sig) {
+        try {
+            process.on(sig, sigListeners[sig]);
+            return true;
+        }
+        catch (er) {
+            return false;
+        }
+    });
+    process.emit = processEmit;
+    process.reallyExit = processReallyExit;
+}
+var originalProcessReallyExit = process.reallyExit;
+function processReallyExit(code) {
+    process.exitCode = code || 0;
+    emit('exit', process.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process.exitCode, null);
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process, process.exitCode);
+}
+var originalProcessEmit = process.emit;
+function processEmit(ev, arg) {
+    if (ev === 'exit') {
+        if (arg !== undefined) {
+            process.exitCode = arg;
+        }
+        var ret = originalProcessEmit.apply(this, arguments);
+        emit('exit', process.exitCode, null);
+        /* istanbul ignore next */
+        emit('afterexit', process.exitCode, null);
+        return ret;
+    }
+    else {
+        return originalProcessEmit.apply(this, arguments);
+    }
+}
+signalExit.unload = unload_1;
+signalExit.signals = signals_1;
+signalExit.load = load_1;
+
+const CLEAR_SCREEN = '\u001Bc';
+function getResetScreen(clearScreen) {
+    if (clearScreen) {
+        return (heading) => stderr(CLEAR_SCREEN + heading);
+    }
+    let firstRun = true;
+    return (heading) => {
+        if (firstRun) {
+            stderr(heading);
+            firstRun = false;
+        }
+    };
+}
+
+function watch(configFile, configs, command, silent = false) {
+    const isTTY = Boolean(process.stderr.isTTY);
+    const warnings = batchWarnings();
+    const initialConfigs = processConfigs(configs);
+    const clearScreen = initialConfigs.every(config => config.watch.clearScreen !== false);
+    const resetScreen = getResetScreen(isTTY && clearScreen);
+    let watcher;
+    let configWatcher;
+    function processConfigs(configs) {
+        return configs.map(options => {
+            const merged = index.mergeOptions({
+                command,
+                config: options,
+                defaultOnWarnHandler: warnings.add
+            });
+            const result = Object.assign({}, merged.inputOptions, { output: merged.outputOptions });
+            if (!result.watch)
+                result.watch = {};
+            if (merged.optionError)
+                merged.inputOptions.onwarn({
+                    code: 'UNKNOWN_OPTION',
+                    message: merged.optionError
+                });
+            return result;
+        });
+    }
+    function start(configs) {
+        watcher = rollup_js.watch(configs);
+        watcher.on('event', (event) => {
+            switch (event.code) {
+                case 'FATAL':
+                    handleError(event.error, true);
+                    process.exit(1);
+                    break;
+                case 'ERROR':
+                    warnings.flush();
+                    handleError(event.error, true);
+                    break;
+                case 'START':
+                    if (!silent) {
+                        resetScreen(turbocolor.underline(`rollup v${index.version}`));
+                    }
+                    break;
+                case 'BUNDLE_START':
+                    if (!silent) {
+                        let input = event.input;
+                        if (typeof input !== 'string') {
+                            input = Array.isArray(input)
+                                ? input.join(', ')
+                                : Object.keys(input)
+                                    .map(key => input[key])
+                                    .join(', ');
+                        }
+                        stderr(turbocolor.cyan(`bundles ${turbocolor.bold(input)} → ${turbocolor.bold(event.output.map(index.relativeId).join(', '))}...`));
+                    }
+                    break;
+                case 'BUNDLE_END':
+                    warnings.flush();
+                    if (!silent)
+                        stderr(turbocolor.green(`created ${turbocolor.bold(event.output.map(index.relativeId).join(', '))} in ${turbocolor.bold(prettyMs(event.duration))}`));
+                    if (event.result && event.result.getTimings) {
+                        printTimings(event.result.getTimings());
+                    }
+                    break;
+                case 'END':
+                    if (!silent && isTTY) {
+                        stderr(`\n[${dateTime_1()}] waiting for changes...`);
+                    }
+            }
+        });
+    }
+    // catch ctrl+c, kill, and uncaught errors
+    const removeOnExit = signalExit(close);
+    process.on('uncaughtException', close);
+    // only listen to stdin if it is a pipe
+    if (!process.stdin.isTTY) {
+        process.stdin.on('end', close); // in case we ever support stdin!
+    }
+    function close(err) {
+        removeOnExit();
+        process.removeListener('uncaughtException', close);
+        // removing a non-existent listener is a no-op
+        process.stdin.removeListener('end', close);
+        if (watcher)
+            watcher.close();
+        if (configWatcher)
+            configWatcher.close();
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        }
+    }
+    try {
+        start(initialConfigs);
+    }
+    catch (err) {
+        close(err);
+        return;
+    }
+    if (configFile && !configFile.startsWith('node:')) {
+        let restarting = false;
+        let aborted = false;
+        let configFileData = fs.readFileSync(configFile, 'utf-8');
+        const restart = () => {
+            const newConfigFileData = fs.readFileSync(configFile, 'utf-8');
+            if (newConfigFileData === configFileData)
+                return;
+            configFileData = newConfigFileData;
+            if (restarting) {
+                aborted = true;
+                return;
+            }
+            restarting = true;
+            loadConfigFile(configFile, command)
+                .then(() => {
+                restarting = false;
+                if (aborted) {
+                    aborted = false;
+                    restart();
+                }
+                else {
+                    watcher.close();
+                    start(initialConfigs);
+                }
+            })
+                .catch((err) => {
+                handleError(err, true);
+            });
+        };
+        configWatcher = fs.watch(configFile, (event) => {
+            if (event === 'change')
+                restart();
+        });
+    }
+}
+
+function runRollup(command) {
+    let inputSource;
+    if (command._.length > 0) {
+        if (command.input) {
+            handleError({
+                code: 'DUPLICATE_IMPORT_OPTIONS',
+                message: 'use --input, or pass input path as argument'
+            });
+        }
+        inputSource = command._;
+    }
+    else if (typeof command.input === 'string') {
+        inputSource = [command.input];
+    }
+    else {
+        inputSource = command.input;
+    }
+    if (inputSource && inputSource.length > 0) {
+        if (inputSource.some((input) => input.indexOf('=') !== -1)) {
+            command.input = {};
+            inputSource.forEach((input) => {
+                const equalsIndex = input.indexOf('=');
+                const value = input.substr(equalsIndex + 1);
+                let key = input.substr(0, equalsIndex);
+                if (!key)
+                    key = index.getAliasName(input);
+                command.input[key] = value;
+            });
+        }
+        else {
+            command.input = inputSource;
+        }
+    }
+    if (command.environment) {
+        const environment = Array.isArray(command.environment)
+            ? command.environment
+            : [command.environment];
+        environment.forEach((arg) => {
+            arg.split(',').forEach((pair) => {
+                const [key, value] = pair.split(':');
+                if (value) {
+                    process.env[key] = value;
+                }
+                else {
+                    process.env[key] = String(true);
+                }
+            });
+        });
+    }
+    let configFile = command.config === true ? 'rollup.config.js' : command.config;
+    if (configFile) {
+        if (configFile.slice(0, 5) === 'node:') {
+            const pkgName = configFile.slice(5);
+            try {
+                configFile = index.relative.resolve(`rollup-config-${pkgName}`, process.cwd());
+            }
+            catch (err) {
+                try {
+                    configFile = index.relative.resolve(pkgName, process.cwd());
+                }
+                catch (err) {
+                    if (err.code === 'MODULE_NOT_FOUND') {
+                        handleError({
+                            code: 'MISSING_EXTERNAL_CONFIG',
+                            message: `Could not resolve config file ${configFile}`
+                        });
+                    }
+                    throw err;
+                }
+            }
+        }
+        else {
+            // find real path of config so it matches what Node provides to callbacks in require.extensions
+            configFile = fs.realpathSync(configFile);
+        }
+        if (command.watch)
+            process.env.ROLLUP_WATCH = 'true';
+        loadConfigFile(configFile, command)
+            .then(configs => execute(configFile, configs, command))
+            .catch(handleError);
+    }
+    else {
+        return execute(configFile, [{ input: null }], command);
+    }
+}
+function execute(configFile, configs, command) {
+    if (command.watch) {
+        watch(configFile, configs, command, command.silent);
+    }
+    else {
+        let promise = Promise.resolve();
+        for (const config of configs) {
+            promise = promise.then(() => {
+                const warnings = batchWarnings();
+                const { inputOptions, outputOptions, optionError } = index.mergeOptions({
+                    command,
+                    config,
+                    defaultOnWarnHandler: warnings.add
+                });
+                if (optionError)
+                    inputOptions.onwarn({ code: 'UNKNOWN_OPTION', message: optionError });
+                return build(inputOptions, outputOptions, warnings, command.silent);
+            });
+        }
+        return promise;
+    }
+}
+
+const command = minimist(process.argv.slice(2), {
+    alias: index.commandAliases
+});
+if (command.help || (process.argv.length <= 2 && process.stdin.isTTY)) {
+    console.log(`\n${help.replace('__VERSION__', index.version)}\n`);
+}
+else if (command.version) {
+    console.log(`rollup v${index.version}`);
+}
+else {
+    try {
+        require('source-map-support').install();
+    }
+    catch (err) {
+        // do nothing
+    }
+    runRollup(command);
+}
+//# sourceMappingURL=rollup.map