@markw65/monkeyc-optimizer 1.0.9 → 1.0.10

package/build/optimizer.cjs

@@ -2,6 +2,782 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
+/***/ 2779:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Buffer = (__webpack_require__(871).Buffer);
+
+var CRC_TABLE = [
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+  0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+  0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+  0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+  0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+  0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+  0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+  0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+  0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+  0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+  0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+  0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+  0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+  0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+  0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+  0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+  0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+  0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+  0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+  0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+  0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+  0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+  0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+  0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+  0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+  0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+  0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+  0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+  0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+  0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+  0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+  0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+  0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+  0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+  0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+  0x2d02ef8d
+];
+
+if (typeof Int32Array !== 'undefined') {
+  CRC_TABLE = new Int32Array(CRC_TABLE);
+}
+
+function ensureBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+
+  var hasNewBufferAPI =
+      typeof Buffer.alloc === "function" &&
+      typeof Buffer.from === "function";
+
+  if (typeof input === "number") {
+    return hasNewBufferAPI ? Buffer.alloc(input) : new Buffer(input);
+  }
+  else if (typeof input === "string") {
+    return hasNewBufferAPI ? Buffer.from(input) : new Buffer(input);
+  }
+  else {
+    throw new Error("input must be buffer, number, or string, received " +
+                    typeof input);
+  }
+}
+
+function bufferizeInt(num) {
+  var tmp = ensureBuffer(4);
+  tmp.writeInt32BE(num, 0);
+  return tmp;
+}
+
+function _crc32(buf, previous) {
+  buf = ensureBuffer(buf);
+  if (Buffer.isBuffer(previous)) {
+    previous = previous.readUInt32BE(0);
+  }
+  var crc = ~~previous ^ -1;
+  for (var n = 0; n < buf.length; n++) {
+    crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ -1);
+}
+
+function crc32() {
+  return bufferizeInt(_crc32.apply(null, arguments));
+}
+crc32.signed = function () {
+  return _crc32.apply(null, arguments);
+};
+crc32.unsigned = function () {
+  return _crc32.apply(null, arguments) >>> 0;
+};
+
+module.exports = crc32;
+
+
+/***/ }),
+
+/***/ 1227:
+/***/ ((module, exports, __webpack_require__) => {
+
+/* eslint-env browser */
+
+/**
+ * This is the web browser implementation of `debug()`.
+ */
+
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
+exports.storage = localstorage();
+exports.destroy = (() => {
+	let warned = false;
+
+	return () => {
+		if (!warned) {
+			warned = true;
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+	};
+})();
+
+/**
+ * Colors.
+ */
+
+exports.colors = [
+	'#0000CC',
+	'#0000FF',
+	'#0033CC',
+	'#0033FF',
+	'#0066CC',
+	'#0066FF',
+	'#0099CC',
+	'#0099FF',
+	'#00CC00',
+	'#00CC33',
+	'#00CC66',
+	'#00CC99',
+	'#00CCCC',
+	'#00CCFF',
+	'#3300CC',
+	'#3300FF',
+	'#3333CC',
+	'#3333FF',
+	'#3366CC',
+	'#3366FF',
+	'#3399CC',
+	'#3399FF',
+	'#33CC00',
+	'#33CC33',
+	'#33CC66',
+	'#33CC99',
+	'#33CCCC',
+	'#33CCFF',
+	'#6600CC',
+	'#6600FF',
+	'#6633CC',
+	'#6633FF',
+	'#66CC00',
+	'#66CC33',
+	'#9900CC',
+	'#9900FF',
+	'#9933CC',
+	'#9933FF',
+	'#99CC00',
+	'#99CC33',
+	'#CC0000',
+	'#CC0033',
+	'#CC0066',
+	'#CC0099',
+	'#CC00CC',
+	'#CC00FF',
+	'#CC3300',
+	'#CC3333',
+	'#CC3366',
+	'#CC3399',
+	'#CC33CC',
+	'#CC33FF',
+	'#CC6600',
+	'#CC6633',
+	'#CC9900',
+	'#CC9933',
+	'#CCCC00',
+	'#CCCC33',
+	'#FF0000',
+	'#FF0033',
+	'#FF0066',
+	'#FF0099',
+	'#FF00CC',
+	'#FF00FF',
+	'#FF3300',
+	'#FF3333',
+	'#FF3366',
+	'#FF3399',
+	'#FF33CC',
+	'#FF33FF',
+	'#FF6600',
+	'#FF6633',
+	'#FF9900',
+	'#FF9933',
+	'#FFCC00',
+	'#FFCC33'
+];
+
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
+ *
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
+ */
+
+// eslint-disable-next-line complexity
+function useColors() {
+	// NB: In an Electron preload script, document will be defined but not fully
+	// initialized. Since we know we're in Chrome, we'll just detect this case
+	// explicitly
+	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+		return true;
+	}
+
+	// Internet Explorer and Edge do not support colors.
+	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		return false;
+	}
+
+	// Is webkit? http://stackoverflow.com/a/16459606/376773
+	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+		// Is firebug? http://stackoverflow.com/a/398120/376773
+		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+		// Is firefox >= v31?
+		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+		// Double check webkit in userAgent just in case we are in a worker
+		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+	args[0] = (this.useColors ? '%c' : '') +
+		this.namespace +
+		(this.useColors ? ' %c' : ' ') +
+		args[0] +
+		(this.useColors ? '%c ' : ' ') +
+		'+' + module.exports.humanize(this.diff);
+
+	if (!this.useColors) {
+		return;
+	}
+
+	const c = 'color: ' + this.color;
+	args.splice(1, 0, c, 'color: inherit');
+
+	// The final "%c" is somewhat tricky, because there could be other
+	// arguments passed either before or after the %c, so we need to
+	// figure out the correct index to insert the CSS into
+	let index = 0;
+	let lastC = 0;
+	args[0].replace(/%[a-zA-Z%]/g, match => {
+		if (match === '%%') {
+			return;
+		}
+		index++;
+		if (match === '%c') {
+			// We only are interested in the *last* %c
+			// (the user may have provided their own)
+			lastC = index;
+		}
+	});
+
+	args.splice(lastC, 0, c);
+}
+
+/**
+ * Invokes `console.debug()` when available.
+ * No-op when `console.debug` is not a "function".
+ * If `console.debug` is not available, falls back
+ * to `console.log`.
+ *
+ * @api public
+ */
+exports.log = console.debug || console.log || (() => {});
+
+/**
+ * Save `namespaces`.
+ *
+ * @param {String} namespaces
+ * @api private
+ */
+function save(namespaces) {
+	try {
+		if (namespaces) {
+			exports.storage.setItem('debug', namespaces);
+		} else {
+			exports.storage.removeItem('debug');
+		}
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
+function load() {
+	let r;
+	try {
+		r = exports.storage.getItem('debug');
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+
+	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+	if (!r && typeof process !== 'undefined' && 'env' in process) {
+		r = process.env.DEBUG;
+	}
+
+	return r;
+}
+
+/**
+ * Localstorage attempts to return the localstorage.
+ *
+ * This is necessary because safari throws
+ * when a user disables cookies/localstorage
+ * and you attempt to access it.
+ *
+ * @return {LocalStorage}
+ * @api private
+ */
+
+function localstorage() {
+	try {
+		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+		// The Browser also has localStorage in the global context.
+		return localStorage;
+	} catch (error) {
+		// Swallow
+		// XXX (@Qix-) should we be logging these?
+	}
+}
+
+module.exports = __webpack_require__(2447)(exports);
+
+const {formatters} = module.exports;
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+formatters.j = function (v) {
+	try {
+		return JSON.stringify(v);
+	} catch (error) {
+		return '[UnexpectedJSONParseError]: ' + error.message;
+	}
+};
+
+
+/***/ }),
+
+/***/ 2447:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ */
+
+function setup(env) {
+	createDebug.debug = createDebug;
+	createDebug.default = createDebug;
+	createDebug.coerce = coerce;
+	createDebug.disable = disable;
+	createDebug.enable = enable;
+	createDebug.enabled = enabled;
+	createDebug.humanize = __webpack_require__(7824);
+	createDebug.destroy = destroy;
+
+	Object.keys(env).forEach(key => {
+		createDebug[key] = env[key];
+	});
+
+	/**
+	* The currently active debug mode names, and names to skip.
+	*/
+
+	createDebug.names = [];
+	createDebug.skips = [];
+
+	/**
+	* Map of special "%n" handling functions, for the debug "format" argument.
+	*
+	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	*/
+	createDebug.formatters = {};
+
+	/**
+	* Selects a color for a debug namespace
+	* @param {String} namespace The namespace string for the debug instance to be colored
+	* @return {Number|String} An ANSI color code for the given namespace
+	* @api private
+	*/
+	function selectColor(namespace) {
+		let hash = 0;
+
+		for (let i = 0; i < namespace.length; i++) {
+			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+			hash |= 0; // Convert to 32bit integer
+		}
+
+		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	}
+	createDebug.selectColor = selectColor;
+
+	/**
+	* Create a debugger with the given `namespace`.
+	*
+	* @param {String} namespace
+	* @return {Function}
+	* @api public
+	*/
+	function createDebug(namespace) {
+		let prevTime;
+		let enableOverride = null;
+		let namespacesCache;
+		let enabledCache;
+
+		function debug(...args) {
+			// Disabled?
+			if (!debug.enabled) {
+				return;
+			}
+
+			const self = debug;
+
+			// Set `diff` timestamp
+			const curr = Number(new Date());
+			const ms = curr - (prevTime || curr);
+			self.diff = ms;
+			self.prev = prevTime;
+			self.curr = curr;
+			prevTime = curr;
+
+			args[0] = createDebug.coerce(args[0]);
+
+			if (typeof args[0] !== 'string') {
+				// Anything else let's inspect with %O
+				args.unshift('%O');
+			}
+
+			// Apply any `formatters` transformations
+			let index = 0;
+			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+				// If we encounter an escaped % then don't increase the array index
+				if (match === '%%') {
+					return '%';
+				}
+				index++;
+				const formatter = createDebug.formatters[format];
+				if (typeof formatter === 'function') {
+					const val = args[index];
+					match = formatter.call(self, val);
+
+					// Now we need to remove `args[index]` since it's inlined in the `format`
+					args.splice(index, 1);
+					index--;
+				}
+				return match;
+			});
+
+			// Apply env-specific formatting (colors, etc.)
+			createDebug.formatArgs.call(self, args);
+
+			const logFn = self.log || createDebug.log;
+			logFn.apply(self, args);
+		}
+
+		debug.namespace = namespace;
+		debug.useColors = createDebug.useColors();
+		debug.color = createDebug.selectColor(namespace);
+		debug.extend = extend;
+		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+		Object.defineProperty(debug, 'enabled', {
+			enumerable: true,
+			configurable: false,
+			get: () => {
+				if (enableOverride !== null) {
+					return enableOverride;
+				}
+				if (namespacesCache !== createDebug.namespaces) {
+					namespacesCache = createDebug.namespaces;
+					enabledCache = createDebug.enabled(namespace);
+				}
+
+				return enabledCache;
+			},
+			set: v => {
+				enableOverride = v;
+			}
+		});
+
+		// Env-specific initialization logic for debug instances
+		if (typeof createDebug.init === 'function') {
+			createDebug.init(debug);
+		}
+
+		return debug;
+	}
+
+	function extend(namespace, delimiter) {
+		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+		newDebug.log = this.log;
+		return newDebug;
+	}
+
+	/**
+	* Enables a debug mode by namespaces. This can include modes
+	* separated by a colon and wildcards.
+	*
+	* @param {String} namespaces
+	* @api public
+	*/
+	function enable(namespaces) {
+		createDebug.save(namespaces);
+		createDebug.namespaces = namespaces;
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		let i;
+		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		const len = split.length;
+
+		for (i = 0; i < len; i++) {
+			if (!split[i]) {
+				// ignore empty strings
+				continue;
+			}
+
+			namespaces = split[i].replace(/\*/g, '.*?');
+
+			if (namespaces[0] === '-') {
+				createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+			} else {
+				createDebug.names.push(new RegExp('^' + namespaces + '$'));
+			}
+		}
+	}
+
+	/**
+	* Disable debug output.
+	*
+	* @return {String} namespaces
+	* @api public
+	*/
+	function disable() {
+		const namespaces = [
+			...createDebug.names.map(toNamespace),
+			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+		].join(',');
+		createDebug.enable('');
+		return namespaces;
+	}
+
+	/**
+	* Returns true if the given mode name is enabled, false otherwise.
+	*
+	* @param {String} name
+	* @return {Boolean}
+	* @api public
+	*/
+	function enabled(name) {
+		if (name[name.length - 1] === '*') {
+			return true;
+		}
+
+		let i;
+		let len;
+
+		for (i = 0, len = createDebug.skips.length; i < len; i++) {
+			if (createDebug.skips[i].test(name)) {
+				return false;
+			}
+		}
+
+		for (i = 0, len = createDebug.names.length; i < len; i++) {
+			if (createDebug.names[i].test(name)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	* Convert regexp to namespace
+	*
+	* @param {RegExp} regxep
+	* @return {String} namespace
+	* @api private
+	*/
+	function toNamespace(regexp) {
+		return regexp.toString()
+			.substring(2, regexp.toString().length - 2)
+			.replace(/\.\*\?$/, '*');
+	}
+
+	/**
+	* Coerce `val`.
+	*
+	* @param {Mixed} val
+	* @return {Mixed}
+	* @api private
+	*/
+	function coerce(val) {
+		if (val instanceof Error) {
+			return val.stack || val.message;
+		}
+		return val;
+	}
+
+	/**
+	* XXX DO NOT USE. This is a temporary stub function.
+	* XXX It WILL be removed in the next major release.
+	*/
+	function destroy() {
+		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+	}
+
+	createDebug.enable(createDebug.load());
+
+	return createDebug;
+}
+
+module.exports = setup;
+
+
+/***/ }),
+
+/***/ 2840:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var once = __webpack_require__(778);
+
+var noop = function() {};
+
+var isRequest = function(stream) {
+	return stream.setHeader && typeof stream.abort === 'function';
+};
+
+var isChildProcess = function(stream) {
+	return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
+};
+
+var eos = function(stream, opts, callback) {
+	if (typeof opts === 'function') return eos(stream, null, opts);
+	if (!opts) opts = {};
+
+	callback = once(callback || noop);
+
+	var ws = stream._writableState;
+	var rs = stream._readableState;
+	var readable = opts.readable || (opts.readable !== false && stream.readable);
+	var writable = opts.writable || (opts.writable !== false && stream.writable);
+	var cancelled = false;
+
+	var onlegacyfinish = function() {
+		if (!stream.writable) onfinish();
+	};
+
+	var onfinish = function() {
+		writable = false;
+		if (!readable) callback.call(stream);
+	};
+
+	var onend = function() {
+		readable = false;
+		if (!writable) callback.call(stream);
+	};
+
+	var onexit = function(exitCode) {
+		callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+	};
+
+	var onerror = function(err) {
+		callback.call(stream, err);
+	};
+
+	var onclose = function() {
+		process.nextTick(onclosenexttick);
+	};
+
+	var onclosenexttick = function() {
+		if (cancelled) return;
+		if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
+		if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));
+	};
+
+	var onrequest = function() {
+		stream.req.on('finish', onfinish);
+	};
+
+	if (isRequest(stream)) {
+		stream.on('complete', onfinish);
+		stream.on('abort', onclose);
+		if (stream.req) onrequest();
+		else stream.on('request', onrequest);
+	} else if (writable && !ws) { // legacy streams
+		stream.on('end', onlegacyfinish);
+		stream.on('close', onlegacyfinish);
+	}
+
+	if (isChildProcess(stream)) stream.on('exit', onexit);
+
+	stream.on('end', onend);
+	stream.on('finish', onfinish);
+	if (opts.error !== false) stream.on('error', onerror);
+	stream.on('close', onclose);
+
+	return function() {
+		cancelled = true;
+		stream.removeListener('complete', onfinish);
+		stream.removeListener('abort', onclose);
+		stream.removeListener('request', onrequest);
+		if (stream.req) stream.req.removeListener('finish', onfinish);
+		stream.removeListener('end', onlegacyfinish);
+		stream.removeListener('close', onlegacyfinish);
+		stream.removeListener('finish', onfinish);
+		stream.removeListener('exit', onexit);
+		stream.removeListener('end', onend);
+		stream.removeListener('error', onerror);
+		stream.removeListener('close', onclose);
+	};
+};
+
+module.exports = eos;
+
+
+/***/ }),
+
 /***/ 7187:
 /***/ ((module) => {
 
@@ -461,49 +1237,1029 @@ function once(emitter, name) {
       reject(err);
     }
 
-    function resolver() {
-      if (typeof emitter.removeListener === 'function') {
-        emitter.removeListener('error', errorListener);
-      }
-      resolve([].slice.call(arguments));
-    };
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    };
+
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+
+/***/ }),
+
+/***/ 2106:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const debug = __webpack_require__(1227)('extract-zip')
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const { createWriteStream, promises: fs } = __webpack_require__(6231)
+const getStream = __webpack_require__(7491)
+const path = __webpack_require__(1423)
+const { promisify } = __webpack_require__(6464)
+const stream = __webpack_require__(8311)
+const yauzl = __webpack_require__(7766)
+
+const openZip = promisify(yauzl.open)
+const pipeline = promisify(stream.pipeline)
+
+class Extractor {
+  constructor (zipPath, opts) {
+    this.zipPath = zipPath
+    this.opts = opts
+  }
+
+  async extract () {
+    debug('opening', this.zipPath, 'with opts', this.opts)
+
+    this.zipfile = await openZip(this.zipPath, { lazyEntries: true })
+    this.canceled = false
+
+    return new Promise((resolve, reject) => {
+      this.zipfile.on('error', err => {
+        this.canceled = true
+        reject(err)
+      })
+      this.zipfile.readEntry()
+
+      this.zipfile.on('close', () => {
+        if (!this.canceled) {
+          debug('zip extraction complete')
+          resolve()
+        }
+      })
+
+      this.zipfile.on('entry', async entry => {
+        /* istanbul ignore if */
+        if (this.canceled) {
+          debug('skipping entry', entry.fileName, { cancelled: this.canceled })
+          return
+        }
+
+        debug('zipfile entry', entry.fileName)
+
+        if (entry.fileName.startsWith('__MACOSX/')) {
+          this.zipfile.readEntry()
+          return
+        }
+
+        const destDir = path.dirname(path.join(this.opts.dir, entry.fileName))
+
+        try {
+          await fs.mkdir(destDir, { recursive: true })
+
+          const canonicalDestDir = await fs.realpath(destDir)
+          const relativeDestDir = path.relative(this.opts.dir, canonicalDestDir)
+
+          if (relativeDestDir.split(path.sep).includes('..')) {
+            throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`)
+          }
+
+          await this.extractEntry(entry)
+          debug('finished processing', entry.fileName)
+          this.zipfile.readEntry()
+        } catch (err) {
+          this.canceled = true
+          this.zipfile.close()
+          reject(err)
+        }
+      })
+    })
+  }
+
+  async extractEntry (entry) {
+    /* istanbul ignore if */
+    if (this.canceled) {
+      debug('skipping entry extraction', entry.fileName, { cancelled: this.canceled })
+      return
+    }
+
+    if (this.opts.onEntry) {
+      this.opts.onEntry(entry, this.zipfile)
+    }
+
+    const dest = path.join(this.opts.dir, entry.fileName)
+
+    // convert external file attr int into a fs stat mode int
+    const mode = (entry.externalFileAttributes >> 16) & 0xFFFF
+    // check if it's a symlink or dir (using stat mode constants)
+    const IFMT = 61440
+    const IFDIR = 16384
+    const IFLNK = 40960
+    const symlink = (mode & IFMT) === IFLNK
+    let isDir = (mode & IFMT) === IFDIR
+
+    // Failsafe, borrowed from jsZip
+    if (!isDir && entry.fileName.endsWith('/')) {
+      isDir = true
+    }
+
+    // check for windows weird way of specifying a directory
+    // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
+    const madeBy = entry.versionMadeBy >> 8
+    if (!isDir) isDir = (madeBy === 0 && entry.externalFileAttributes === 16)
+
+    debug('extracting entry', { filename: entry.fileName, isDir: isDir, isSymlink: symlink })
+
+    const procMode = this.getExtractedMode(mode, isDir) & 0o777
+
+    // always ensure folders are created
+    const destDir = isDir ? dest : path.dirname(dest)
+
+    const mkdirOptions = { recursive: true }
+    if (isDir) {
+      mkdirOptions.mode = procMode
+    }
+    debug('mkdir', { dir: destDir, ...mkdirOptions })
+    await fs.mkdir(destDir, mkdirOptions)
+    if (isDir) return
+
+    debug('opening read stream', dest)
+    const readStream = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry)
+
+    if (symlink) {
+      const link = await getStream(readStream)
+      debug('creating symlink', link, dest)
+      await fs.symlink(link, dest)
+    } else {
+      await pipeline(readStream, createWriteStream(dest, { mode: procMode }))
+    }
+  }
+
+  getExtractedMode (entryMode, isDir) {
+    let mode = entryMode
+    // Set defaults, if necessary
+    if (mode === 0) {
+      if (isDir) {
+        if (this.opts.defaultDirMode) {
+          mode = parseInt(this.opts.defaultDirMode, 10)
+        }
+
+        if (!mode) {
+          mode = 0o755
+        }
+      } else {
+        if (this.opts.defaultFileMode) {
+          mode = parseInt(this.opts.defaultFileMode, 10)
+        }
+
+        if (!mode) {
+          mode = 0o644
+        }
+      }
+    }
+
+    return mode
+  }
+}
+
+module.exports = async function (zipPath, opts) {
+  debug('creating target directory', opts.dir)
+
+  if (!path.isAbsolute(opts.dir)) {
+    throw new Error('Target directory is expected to be absolute')
+  }
+
+  await fs.mkdir(opts.dir, { recursive: true })
+  opts.dir = await fs.realpath(opts.dir)
+  return new Extractor(zipPath, opts).extract()
+}
+
+
+/***/ }),
+
+/***/ 2297:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {PassThrough: PassThroughStream} = __webpack_require__(8311);
+
+module.exports = options => {
+	options = {...options};
+
+	const {array} = options;
+	let {encoding} = options;
+	const isBuffer = encoding === 'buffer';
+	let objectMode = false;
+
+	if (array) {
+		objectMode = !(encoding || isBuffer);
+	} else {
+		encoding = encoding || 'utf8';
+	}
+
+	if (isBuffer) {
+		encoding = null;
+	}
+
+	const stream = new PassThroughStream({objectMode});
+
+	if (encoding) {
+		stream.setEncoding(encoding);
+	}
+
+	let length = 0;
+	const chunks = [];
+
+	stream.on('data', chunk => {
+		chunks.push(chunk);
+
+		if (objectMode) {
+			length = chunks.length;
+		} else {
+			length += chunk.length;
+		}
+	});
+
+	stream.getBufferedValue = () => {
+		if (array) {
+			return chunks;
+		}
+
+		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
+	};
+
+	stream.getBufferedLength = () => length;
+
+	return stream;
+};
+
+
+/***/ }),
+
+/***/ 7491:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {constants: BufferConstants} = __webpack_require__(871);
+const pump = __webpack_require__(4286);
+const bufferStream = __webpack_require__(2297);
+
+class MaxBufferError extends Error {
+	constructor() {
+		super('maxBuffer exceeded');
+		this.name = 'MaxBufferError';
+	}
+}
+
+async function getStream(inputStream, options) {
+	if (!inputStream) {
+		return Promise.reject(new Error('Expected a stream'));
+	}
+
+	options = {
+		maxBuffer: Infinity,
+		...options
+	};
+
+	const {maxBuffer} = options;
+
+	let stream;
+	await new Promise((resolve, reject) => {
+		const rejectPromise = error => {
+			// Don't retrieve an oversized buffer.
+			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+				error.bufferedData = stream.getBufferedValue();
+			}
+
+			reject(error);
+		};
+
+		stream = pump(inputStream, bufferStream(options), error => {
+			if (error) {
+				rejectPromise(error);
+				return;
+			}
+
+			resolve();
+		});
+
+		stream.on('data', () => {
+			if (stream.getBufferedLength() > maxBuffer) {
+				rejectPromise(new MaxBufferError());
+			}
+		});
+	});
+
+	return stream.getBufferedValue();
+}
+
+module.exports = getStream;
+// TODO: Remove this for the next major release
+module.exports["default"] = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+module.exports.MaxBufferError = MaxBufferError;
+
+
+/***/ }),
+
+/***/ 8913:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var fs = __webpack_require__(6231);
+var util = __webpack_require__(6464);
+var stream = __webpack_require__(8311);
+var Readable = stream.Readable;
+var Writable = stream.Writable;
+var PassThrough = stream.PassThrough;
+var Pend = __webpack_require__(9916);
+var EventEmitter = (__webpack_require__(7187).EventEmitter);
+
+exports.createFromBuffer = createFromBuffer;
+exports.createFromFd = createFromFd;
+exports.BufferSlicer = BufferSlicer;
+exports.FdSlicer = FdSlicer;
+
+util.inherits(FdSlicer, EventEmitter);
+function FdSlicer(fd, options) {
+  options = options || {};
+  EventEmitter.call(this);
+
+  this.fd = fd;
+  this.pend = new Pend();
+  this.pend.max = 1;
+  this.refCount = 0;
+  this.autoClose = !!options.autoClose;
+}
+
+FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+  var self = this;
+  self.pend.go(function(cb) {
+    fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer) {
+      cb();
+      callback(err, bytesRead, buffer);
+    });
+  });
+};
+
+FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+  var self = this;
+  self.pend.go(function(cb) {
+    fs.write(self.fd, buffer, offset, length, position, function(err, written, buffer) {
+      cb();
+      callback(err, written, buffer);
+    });
+  });
+};
+
+FdSlicer.prototype.createReadStream = function(options) {
+  return new ReadStream(this, options);
+};
+
+FdSlicer.prototype.createWriteStream = function(options) {
+  return new WriteStream(this, options);
+};
+
+FdSlicer.prototype.ref = function() {
+  this.refCount += 1;
+};
+
+FdSlicer.prototype.unref = function() {
+  var self = this;
+  self.refCount -= 1;
+
+  if (self.refCount > 0) return;
+  if (self.refCount < 0) throw new Error("invalid unref");
+
+  if (self.autoClose) {
+    fs.close(self.fd, onCloseDone);
+  }
+
+  function onCloseDone(err) {
+    if (err) {
+      self.emit('error', err);
+    } else {
+      self.emit('close');
+    }
+  }
+};
+
+util.inherits(ReadStream, Readable);
+function ReadStream(context, options) {
+  options = options || {};
+  Readable.call(this, options);
+
+  this.context = context;
+  this.context.ref();
+
+  this.start = options.start || 0;
+  this.endOffset = options.end;
+  this.pos = this.start;
+  this.destroyed = false;
+}
+
+ReadStream.prototype._read = function(n) {
+  var self = this;
+  if (self.destroyed) return;
+
+  var toRead = Math.min(self._readableState.highWaterMark, n);
+  if (self.endOffset != null) {
+    toRead = Math.min(toRead, self.endOffset - self.pos);
+  }
+  if (toRead <= 0) {
+    self.destroyed = true;
+    self.push(null);
+    self.context.unref();
+    return;
+  }
+  self.context.pend.go(function(cb) {
+    if (self.destroyed) return cb();
+    var buffer = new Buffer(toRead);
+    fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+      if (err) {
+        self.destroy(err);
+      } else if (bytesRead === 0) {
+        self.destroyed = true;
+        self.push(null);
+        self.context.unref();
+      } else {
+        self.pos += bytesRead;
+        self.push(buffer.slice(0, bytesRead));
+      }
+      cb();
+    });
+  });
+};
+
+ReadStream.prototype.destroy = function(err) {
+  if (this.destroyed) return;
+  err = err || new Error("stream destroyed");
+  this.destroyed = true;
+  this.emit('error', err);
+  this.context.unref();
+};
+
+util.inherits(WriteStream, Writable);
+function WriteStream(context, options) {
+  options = options || {};
+  Writable.call(this, options);
+
+  this.context = context;
+  this.context.ref();
+
+  this.start = options.start || 0;
+  this.endOffset = (options.end == null) ? Infinity : +options.end;
+  this.bytesWritten = 0;
+  this.pos = this.start;
+  this.destroyed = false;
+
+  this.on('finish', this.destroy.bind(this));
+}
+
+WriteStream.prototype._write = function(buffer, encoding, callback) {
+  var self = this;
+  if (self.destroyed) return;
+
+  if (self.pos + buffer.length > self.endOffset) {
+    var err = new Error("maximum file length exceeded");
+    err.code = 'ETOOBIG';
+    self.destroy();
+    callback(err);
+    return;
+  }
+  self.context.pend.go(function(cb) {
+    if (self.destroyed) return cb();
+    fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err, bytes) {
+      if (err) {
+        self.destroy();
+        cb();
+        callback(err);
+      } else {
+        self.bytesWritten += bytes;
+        self.pos += bytes;
+        self.emit('progress');
+        cb();
+        callback();
+      }
+    });
+  });
+};
+
+WriteStream.prototype.destroy = function() {
+  if (this.destroyed) return;
+  this.destroyed = true;
+  this.context.unref();
+};
+
+util.inherits(BufferSlicer, EventEmitter);
+function BufferSlicer(buffer, options) {
+  EventEmitter.call(this);
+
+  options = options || {};
+  this.refCount = 0;
+  this.buffer = buffer;
+  this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER;
+}
+
+BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+  var end = position + length;
+  var delta = end - this.buffer.length;
+  var written = (delta > 0) ? delta : length;
+  this.buffer.copy(buffer, offset, position, end);
+  setImmediate(function() {
+    callback(null, written);
+  });
+};
+
+BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+  buffer.copy(this.buffer, position, offset, offset + length);
+  setImmediate(function() {
+    callback(null, length, buffer);
+  });
+};
+
+BufferSlicer.prototype.createReadStream = function(options) {
+  options = options || {};
+  var readStream = new PassThrough(options);
+  readStream.destroyed = false;
+  readStream.start = options.start || 0;
+  readStream.endOffset = options.end;
+  // by the time this function returns, we'll be done.
+  readStream.pos = readStream.endOffset || this.buffer.length;
+
+  // respect the maxChunkSize option to slice up the chunk into smaller pieces.
+  var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+  var offset = 0;
+  while (true) {
+    var nextOffset = offset + this.maxChunkSize;
+    if (nextOffset >= entireSlice.length) {
+      // last chunk
+      if (offset < entireSlice.length) {
+        readStream.write(entireSlice.slice(offset, entireSlice.length));
+      }
+      break;
+    }
+    readStream.write(entireSlice.slice(offset, nextOffset));
+    offset = nextOffset;
+  }
+
+  readStream.end();
+  readStream.destroy = function() {
+    readStream.destroyed = true;
+  };
+  return readStream;
+};
+
+BufferSlicer.prototype.createWriteStream = function(options) {
+  var bufferSlicer = this;
+  options = options || {};
+  var writeStream = new Writable(options);
+  writeStream.start = options.start || 0;
+  writeStream.endOffset = (options.end == null) ? this.buffer.length : +options.end;
+  writeStream.bytesWritten = 0;
+  writeStream.pos = writeStream.start;
+  writeStream.destroyed = false;
+  writeStream._write = function(buffer, encoding, callback) {
+    if (writeStream.destroyed) return;
+
+    var end = writeStream.pos + buffer.length;
+    if (end > writeStream.endOffset) {
+      var err = new Error("maximum file length exceeded");
+      err.code = 'ETOOBIG';
+      writeStream.destroyed = true;
+      callback(err);
+      return;
+    }
+    buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
+
+    writeStream.bytesWritten += buffer.length;
+    writeStream.pos = end;
+    writeStream.emit('progress');
+    callback();
+  };
+  writeStream.destroy = function() {
+    writeStream.destroyed = true;
+  };
+  return writeStream;
+};
+
+BufferSlicer.prototype.ref = function() {
+  this.refCount += 1;
+};
+
+BufferSlicer.prototype.unref = function() {
+  this.refCount -= 1;
+
+  if (this.refCount < 0) {
+    throw new Error("invalid unref");
+  }
+};
+
+function createFromBuffer(buffer, options) {
+  return new BufferSlicer(buffer, options);
+}
+
+function createFromFd(fd, options) {
+  return new FdSlicer(fd, options);
+}
+
+
+/***/ }),
+
+/***/ 7824:
+/***/ ((module) => {
+
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}
+
+
+/***/ }),
+
+/***/ 778:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var wrappy = __webpack_require__(2479)
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
+
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once(this)
+    },
+    configurable: true
+  })
+
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  })
+})
+
+function once (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  f.called = false
+  return f
+}
+
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  var name = fn.name || 'Function wrapped with `once`'
+  f.onceError = name + " shouldn't be called more than once"
+  f.called = false
+  return f
+}
+
+
+/***/ }),
+
+/***/ 9916:
+/***/ ((module) => {
+
+module.exports = Pend;
+
+function Pend() {
+  this.pending = 0;
+  this.max = Infinity;
+  this.listeners = [];
+  this.waiting = [];
+  this.error = null;
+}
+
+Pend.prototype.go = function(fn) {
+  if (this.pending < this.max) {
+    pendGo(this, fn);
+  } else {
+    this.waiting.push(fn);
+  }
+};
+
+Pend.prototype.wait = function(cb) {
+  if (this.pending === 0) {
+    cb(this.error);
+  } else {
+    this.listeners.push(cb);
+  }
+};
+
+Pend.prototype.hold = function() {
+  return pendHold(this);
+};
+
+function pendHold(self) {
+  self.pending += 1;
+  var called = false;
+  return onCb;
+  function onCb(err) {
+    if (called) throw new Error("callback called twice");
+    called = true;
+    self.error = self.error || err;
+    self.pending -= 1;
+    if (self.waiting.length > 0 && self.pending < self.max) {
+      pendGo(self, self.waiting.shift());
+    } else if (self.pending === 0) {
+      var listeners = self.listeners;
+      self.listeners = [];
+      listeners.forEach(cbListener);
+    }
+  }
+  function cbListener(listener) {
+    listener(self.error);
+  }
+}
+
+function pendGo(self, fn) {
+  fn(pendHold(self));
+}
+
+
+/***/ }),
+
+/***/ 4286:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var once = __webpack_require__(778)
+var eos = __webpack_require__(2840)
+var fs = __webpack_require__(6231) // we only need fs to get the ReadStream and WriteStream prototypes
+
+var noop = function () {}
+var ancient = /^v?\.0/.test(process.version)
+
+var isFn = function (fn) {
+  return typeof fn === 'function'
+}
+
+var isFS = function (stream) {
+  if (!ancient) return false // newer node version do not need to care about fs is a special way
+  if (!fs) return false // browser
+  return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
+}
 
-    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-    if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-    }
-  });
+var isRequest = function (stream) {
+  return stream.setHeader && isFn(stream.abort)
 }
 
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-  if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+var destroyer = function (stream, reading, writing, callback) {
+  callback = once(callback)
+
+  var closed = false
+  stream.on('close', function () {
+    closed = true
+  })
+
+  eos(stream, {readable: reading, writable: writing}, function (err) {
+    if (err) return callback(err)
+    closed = true
+    callback()
+  })
+
+  var destroyed = false
+  return function (err) {
+    if (closed) return
+    if (destroyed) return
+    destroyed = true
+
+    if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
+    if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
+
+    if (isFn(stream.destroy)) return stream.destroy()
+
+    callback(err || new Error('stream was destroyed'))
   }
 }
 
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-  if (typeof emitter.on === 'function') {
-    if (flags.once) {
-      emitter.once(name, listener);
-    } else {
-      emitter.on(name, listener);
-    }
-  } else if (typeof emitter.addEventListener === 'function') {
-    // EventTarget does not have `error` event semantics like Node
-    // EventEmitters, we do not listen for `error` events here.
-    emitter.addEventListener(name, function wrapListener(arg) {
-      // IE does not have builtin `{ once: true }` support so we
-      // have to do it manually.
-      if (flags.once) {
-        emitter.removeEventListener(name, wrapListener);
-      }
-      listener(arg);
-    });
-  } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-  }
+var call = function (fn) {
+  fn()
+}
+
+var pipe = function (from, to) {
+  return from.pipe(to)
+}
+
+var pump = function () {
+  var streams = Array.prototype.slice.call(arguments)
+  var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
+
+  if (Array.isArray(streams[0])) streams = streams[0]
+  if (streams.length < 2) throw new Error('pump requires two streams per minimum')
+
+  var error
+  var destroys = streams.map(function (stream, i) {
+    var reading = i < streams.length - 1
+    var writing = i > 0
+    return destroyer(stream, reading, writing, function (err) {
+      if (!error) error = err
+      if (err) destroys.forEach(call)
+      if (reading) return
+      destroys.forEach(call)
+      callback(error)
+    })
+  })
+
+  return streams.reduce(pipe)
 }
 
+module.exports = pump
+
 
 /***/ }),
 
@@ -2077,6 +3833,46 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 })( false ? 0 : exports)
 
 
+/***/ }),
+
+/***/ 2479:
+/***/ ((module) => {
+
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+  if (fn && cb) return wrappy(fn)(cb)
+
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
+
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k]
+  })
+
+  return wrapper
+
+  function wrapper() {
+    var args = new Array(arguments.length)
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i]
+    }
+    var ret = fn.apply(this, args)
+    var cb = args[args.length-1]
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k]
+      })
+    }
+    return ret
+  }
+}
+
+
 /***/ }),
 
 /***/ 306:
@@ -4694,7 +6490,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 
 /***/ }),
 
-/***/ 459:
+/***/ 8833:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 // Generated by CoffeeScript 1.12.7
@@ -5157,7 +6953,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
         XMLRaw = __webpack_require__(9406);
         XMLText = __webpack_require__(3595);
         XMLProcessingInstruction = __webpack_require__(9181);
-        XMLDummy = __webpack_require__(459);
+        XMLDummy = __webpack_require__(8833);
         NodeType = __webpack_require__(9335);
         XMLNodeList = __webpack_require__(2390);
         XMLNamedNodeMap = __webpack_require__(663);
@@ -6603,7 +8399,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 
   XMLProcessingInstruction = __webpack_require__(9181);
 
-  XMLDummy = __webpack_require__(459);
+  XMLDummy = __webpack_require__(8833);
 
   XMLDTDAttList = __webpack_require__(1179);
 
@@ -7017,68 +8813,895 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 (function() {
   var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
 
-  ref = __webpack_require__(8369), assign = ref.assign, isFunction = ref.isFunction;
+  ref = __webpack_require__(8369), assign = ref.assign, isFunction = ref.isFunction;
+
+  XMLDOMImplementation = __webpack_require__(1770);
+
+  XMLDocument = __webpack_require__(6934);
+
+  XMLDocumentCB = __webpack_require__(9227);
+
+  XMLStringWriter = __webpack_require__(6434);
+
+  XMLStreamWriter = __webpack_require__(1996);
+
+  NodeType = __webpack_require__(9335);
+
+  WriterState = __webpack_require__(594);
+
+  module.exports.create = function(name, xmldec, doctype, options) {
+    var doc, root;
+    if (name == null) {
+      throw new Error("Root element needs a name.");
+    }
+    options = assign({}, xmldec, doctype, options);
+    doc = new XMLDocument(options);
+    root = doc.element(name);
+    if (!options.headless) {
+      doc.declaration(options);
+      if ((options.pubID != null) || (options.sysID != null)) {
+        doc.dtd(options);
+      }
+    }
+    return root;
+  };
+
+  module.exports.begin = function(options, onData, onEnd) {
+    var ref1;
+    if (isFunction(options)) {
+      ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
+      options = {};
+    }
+    if (onData) {
+      return new XMLDocumentCB(options, onData, onEnd);
+    } else {
+      return new XMLDocument(options);
+    }
+  };
+
+  module.exports.stringWriter = function(options) {
+    return new XMLStringWriter(options);
+  };
+
+  module.exports.streamWriter = function(stream, options) {
+    return new XMLStreamWriter(stream, options);
+  };
+
+  module.exports.implementation = new XMLDOMImplementation();
+
+  module.exports.nodeType = NodeType;
+
+  module.exports.writerState = WriterState;
+
+}).call(this);
+
+
+/***/ }),
+
+/***/ 7766:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+var fs = __webpack_require__(6231);
+var zlib = __webpack_require__(8884);
+var fd_slicer = __webpack_require__(8913);
+var crc32 = __webpack_require__(2779);
+var util = __webpack_require__(6464);
+var EventEmitter = (__webpack_require__(7187).EventEmitter);
+var Transform = (__webpack_require__(8311).Transform);
+var PassThrough = (__webpack_require__(8311).PassThrough);
+var Writable = (__webpack_require__(8311).Writable);
+
+exports.open = open;
+exports.fromFd = fromFd;
+exports.fromBuffer = fromBuffer;
+exports.fromRandomAccessReader = fromRandomAccessReader;
+exports.dosDateTimeToDate = dosDateTimeToDate;
+exports.validateFileName = validateFileName;
+exports.ZipFile = ZipFile;
+exports.Entry = Entry;
+exports.RandomAccessReader = RandomAccessReader;
+
+function open(path, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  if (options == null) options = {};
+  if (options.autoClose == null) options.autoClose = true;
+  if (options.lazyEntries == null) options.lazyEntries = false;
+  if (options.decodeStrings == null) options.decodeStrings = true;
+  if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+  if (options.strictFileNames == null) options.strictFileNames = false;
+  if (callback == null) callback = defaultCallback;
+  fs.open(path, "r", function(err, fd) {
+    if (err) return callback(err);
+    fromFd(fd, options, function(err, zipfile) {
+      if (err) fs.close(fd, defaultCallback);
+      callback(err, zipfile);
+    });
+  });
+}
+
+function fromFd(fd, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  if (options == null) options = {};
+  if (options.autoClose == null) options.autoClose = false;
+  if (options.lazyEntries == null) options.lazyEntries = false;
+  if (options.decodeStrings == null) options.decodeStrings = true;
+  if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+  if (options.strictFileNames == null) options.strictFileNames = false;
+  if (callback == null) callback = defaultCallback;
+  fs.fstat(fd, function(err, stats) {
+    if (err) return callback(err);
+    var reader = fd_slicer.createFromFd(fd, {autoClose: true});
+    fromRandomAccessReader(reader, stats.size, options, callback);
+  });
+}
+
+function fromBuffer(buffer, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  if (options == null) options = {};
+  options.autoClose = false;
+  if (options.lazyEntries == null) options.lazyEntries = false;
+  if (options.decodeStrings == null) options.decodeStrings = true;
+  if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+  if (options.strictFileNames == null) options.strictFileNames = false;
+  // limit the max chunk size. see https://github.com/thejoshwolfe/yauzl/issues/87
+  var reader = fd_slicer.createFromBuffer(buffer, {maxChunkSize: 0x10000});
+  fromRandomAccessReader(reader, buffer.length, options, callback);
+}
+
+function fromRandomAccessReader(reader, totalSize, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = null;
+  }
+  if (options == null) options = {};
+  if (options.autoClose == null) options.autoClose = true;
+  if (options.lazyEntries == null) options.lazyEntries = false;
+  if (options.decodeStrings == null) options.decodeStrings = true;
+  var decodeStrings = !!options.decodeStrings;
+  if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+  if (options.strictFileNames == null) options.strictFileNames = false;
+  if (callback == null) callback = defaultCallback;
+  if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
+  if (totalSize > Number.MAX_SAFE_INTEGER) {
+    throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+  }
+
+  // the matching unref() call is in zipfile.close()
+  reader.ref();
+
+  // eocdr means End of Central Directory Record.
+  // search backwards for the eocdr signature.
+  // the last field of the eocdr is a variable-length comment.
+  // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it.
+  // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment.
+  // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment.
+  var eocdrWithoutCommentSize = 22;
+  var maxCommentSize = 0xffff; // 2-byte size
+  var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
+  var buffer = newBuffer(bufferSize);
+  var bufferReadStart = totalSize - buffer.length;
+  readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+    if (err) return callback(err);
+    for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
+      if (buffer.readUInt32LE(i) !== 0x06054b50) continue;
+      // found eocdr
+      var eocdrBuffer = buffer.slice(i);
+
+      // 0 - End of central directory signature = 0x06054b50
+      // 4 - Number of this disk
+      var diskNumber = eocdrBuffer.readUInt16LE(4);
+      if (diskNumber !== 0) {
+        return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+      }
+      // 6 - Disk where central directory starts
+      // 8 - Number of central directory records on this disk
+      // 10 - Total number of central directory records
+      var entryCount = eocdrBuffer.readUInt16LE(10);
+      // 12 - Size of central directory (bytes)
+      // 16 - Offset of start of central directory, relative to start of archive
+      var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+      // 20 - Comment length
+      var commentLength = eocdrBuffer.readUInt16LE(20);
+      var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+      if (commentLength !== expectedCommentLength) {
+        return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
+      }
+      // 22 - Comment
+      // the encoding is always cp437.
+      var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false)
+                                  : eocdrBuffer.slice(22);
+
+      if (!(entryCount === 0xffff || centralDirectoryOffset === 0xffffffff)) {
+        return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+      }
+
+      // ZIP64 format
+
+      // ZIP64 Zip64 end of central directory locator
+      var zip64EocdlBuffer = newBuffer(20);
+      var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
+      readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err) {
+        if (err) return callback(err);
+
+        // 0 - zip64 end of central dir locator signature = 0x07064b50
+        if (zip64EocdlBuffer.readUInt32LE(0) !== 0x07064b50) {
+          return callback(new Error("invalid zip64 end of central directory locator signature"));
+        }
+        // 4 - number of the disk with the start of the zip64 end of central directory
+        // 8 - relative offset of the zip64 end of central directory record
+        var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+        // 16 - total number of disks
+
+        // ZIP64 end of central directory record
+        var zip64EocdrBuffer = newBuffer(56);
+        readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) {
+          if (err) return callback(err);
+
+          // 0 - zip64 end of central dir signature                           4 bytes  (0x06064b50)
+          if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) {
+            return callback(new Error("invalid zip64 end of central directory record signature"));
+          }
+          // 4 - size of zip64 end of central directory record                8 bytes
+          // 12 - version made by                                             2 bytes
+          // 14 - version needed to extract                                   2 bytes
+          // 16 - number of this disk                                         4 bytes
+          // 20 - number of the disk with the start of the central directory  4 bytes
+          // 24 - total number of entries in the central directory on this disk         8 bytes
+          // 32 - total number of entries in the central directory            8 bytes
+          entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+          // 40 - size of the central directory                               8 bytes
+          // 48 - offset of start of central directory with respect to the starting disk number     8 bytes
+          centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+          // 56 - zip64 extensible data sector                                (variable size)
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+        });
+      });
+      return;
+    }
+    callback(new Error("end of central directory record signature not found"));
+  });
+}
+
+util.inherits(ZipFile, EventEmitter);
+function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+  var self = this;
+  EventEmitter.call(self);
+  self.reader = reader;
+  // forward close events
+  self.reader.on("error", function(err) {
+    // error closing the fd
+    emitError(self, err);
+  });
+  self.reader.once("close", function() {
+    self.emit("close");
+  });
+  self.readEntryCursor = centralDirectoryOffset;
+  self.fileSize = fileSize;
+  self.entryCount = entryCount;
+  self.comment = comment;
+  self.entriesRead = 0;
+  self.autoClose = !!autoClose;
+  self.lazyEntries = !!lazyEntries;
+  self.decodeStrings = !!decodeStrings;
+  self.validateEntrySizes = !!validateEntrySizes;
+  self.strictFileNames = !!strictFileNames;
+  self.isOpen = true;
+  self.emittedError = false;
+
+  if (!self.lazyEntries) self._readEntry();
+}
+ZipFile.prototype.close = function() {
+  if (!this.isOpen) return;
+  this.isOpen = false;
+  this.reader.unref();
+};
+
+function emitErrorAndAutoClose(self, err) {
+  if (self.autoClose) self.close();
+  emitError(self, err);
+}
+function emitError(self, err) {
+  if (self.emittedError) return;
+  self.emittedError = true;
+  self.emit("error", err);
+}
+
+ZipFile.prototype.readEntry = function() {
+  if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
+  this._readEntry();
+};
+ZipFile.prototype._readEntry = function() {
+  var self = this;
+  if (self.entryCount === self.entriesRead) {
+    // done with metadata
+    setImmediate(function() {
+      if (self.autoClose) self.close();
+      if (self.emittedError) return;
+      self.emit("end");
+    });
+    return;
+  }
+  if (self.emittedError) return;
+  var buffer = newBuffer(46);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+    if (err) return emitErrorAndAutoClose(self, err);
+    if (self.emittedError) return;
+    var entry = new Entry();
+    // 0 - Central directory file header signature
+    var signature = buffer.readUInt32LE(0);
+    if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+    // 4 - Version made by
+    entry.versionMadeBy = buffer.readUInt16LE(4);
+    // 6 - Version needed to extract (minimum)
+    entry.versionNeededToExtract = buffer.readUInt16LE(6);
+    // 8 - General purpose bit flag
+    entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+    // 10 - Compression method
+    entry.compressionMethod = buffer.readUInt16LE(10);
+    // 12 - File last modification time
+    entry.lastModFileTime = buffer.readUInt16LE(12);
+    // 14 - File last modification date
+    entry.lastModFileDate = buffer.readUInt16LE(14);
+    // 16 - CRC-32
+    entry.crc32 = buffer.readUInt32LE(16);
+    // 20 - Compressed size
+    entry.compressedSize = buffer.readUInt32LE(20);
+    // 24 - Uncompressed size
+    entry.uncompressedSize = buffer.readUInt32LE(24);
+    // 28 - File name length (n)
+    entry.fileNameLength = buffer.readUInt16LE(28);
+    // 30 - Extra field length (m)
+    entry.extraFieldLength = buffer.readUInt16LE(30);
+    // 32 - File comment length (k)
+    entry.fileCommentLength = buffer.readUInt16LE(32);
+    // 34 - Disk number where file starts
+    // 36 - Internal file attributes
+    entry.internalFileAttributes = buffer.readUInt16LE(36);
+    // 38 - External file attributes
+    entry.externalFileAttributes = buffer.readUInt32LE(38);
+    // 42 - Relative offset of local file header
+    entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+
+    if (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
+
+    self.readEntryCursor += 46;
+
+    buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+      if (err) return emitErrorAndAutoClose(self, err);
+      if (self.emittedError) return;
+      // 46 - File name
+      var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;
+      entry.fileName = self.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8)
+                                          : buffer.slice(0, entry.fileNameLength);
+
+      // 46+n - Extra field
+      var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+      var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
+      entry.extraFields = [];
+      var i = 0;
+      while (i < extraFieldBuffer.length - 3) {
+        var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+        var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+        var dataStart = i + 4;
+        var dataEnd = dataStart + dataSize;
+        if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self, new Error("extra field length exceeds extra field buffer size"));
+        var dataBuffer = newBuffer(dataSize);
+        extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
+        entry.extraFields.push({
+          id: headerId,
+          data: dataBuffer,
+        });
+        i = dataEnd;
+      }
+
+      // 46+n+m - File comment
+      entry.fileComment = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8)
+                                             : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+      // compatibility hack for https://github.com/thejoshwolfe/yauzl/issues/47
+      entry.comment = entry.fileComment;
+
+      self.readEntryCursor += buffer.length;
+      self.entriesRead += 1;
+
+      if (entry.uncompressedSize            === 0xffffffff ||
+          entry.compressedSize              === 0xffffffff ||
+          entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+        // ZIP64 format
+        // find the Zip64 Extended Information Extra Field
+        var zip64EiefBuffer = null;
+        for (var i = 0; i < entry.extraFields.length; i++) {
+          var extraField = entry.extraFields[i];
+          if (extraField.id === 0x0001) {
+            zip64EiefBuffer = extraField.data;
+            break;
+          }
+        }
+        if (zip64EiefBuffer == null) {
+          return emitErrorAndAutoClose(self, new Error("expected zip64 extended information extra field"));
+        }
+        var index = 0;
+        // 0 - Original Size          8 bytes
+        if (entry.uncompressedSize === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+          }
+          entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 8 - Compressed Size        8 bytes
+        if (entry.compressedSize === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+          }
+          entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 16 - Relative Header Offset 8 bytes
+        if (entry.relativeOffsetOfLocalHeader === 0xffffffff) {
+          if (index + 8 > zip64EiefBuffer.length) {
+            return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+          }
+          entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+          index += 8;
+        }
+        // 24 - Disk Start Number      4 bytes
+      }
+
+      // check for Info-ZIP Unicode Path Extra Field (0x7075)
+      // see https://github.com/thejoshwolfe/yauzl/issues/33
+      if (self.decodeStrings) {
+        for (var i = 0; i < entry.extraFields.length; i++) {
+          var extraField = entry.extraFields[i];
+          if (extraField.id === 0x7075) {
+            if (extraField.data.length < 6) {
+              // too short to be meaningful
+              continue;
+            }
+            // Version       1 byte      version of this extra field, currently 1
+            if (extraField.data.readUInt8(0) !== 1) {
+              // > Changes may not be backward compatible so this extra
+              // > field should not be used if the version is not recognized.
+              continue;
+            }
+            // NameCRC32     4 bytes     File Name Field CRC32 Checksum
+            var oldNameCrc32 = extraField.data.readUInt32LE(1);
+            if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
+              // > If the CRC check fails, this UTF-8 Path Extra Field should be
+              // > ignored and the File Name field in the header should be used instead.
+              continue;
+            }
+            // UnicodeName   Variable    UTF-8 version of the entry File Name
+            entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
+            break;
+          }
+        }
+      }
+
+      // validate file size
+      if (self.validateEntrySizes && entry.compressionMethod === 0) {
+        var expectedCompressedSize = entry.uncompressedSize;
+        if (entry.isEncrypted()) {
+          // traditional encryption prefixes the file data with a header
+          expectedCompressedSize += 12;
+        }
+        if (entry.compressedSize !== expectedCompressedSize) {
+          var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+          return emitErrorAndAutoClose(self, new Error(msg));
+        }
+      }
+
+      if (self.decodeStrings) {
+        if (!self.strictFileNames) {
+          // allow backslash
+          entry.fileName = entry.fileName.replace(/\\/g, "/");
+        }
+        var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
+        if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
+      }
+      self.emit("entry", entry);
+
+      if (!self.lazyEntries) self._readEntry();
+    });
+  });
+};
+
+ZipFile.prototype.openReadStream = function(entry, options, callback) {
+  var self = this;
+  // parameter validation
+  var relativeStart = 0;
+  var relativeEnd = entry.compressedSize;
+  if (callback == null) {
+    callback = options;
+    options = {};
+  } else {
+    // validate options that the caller has no excuse to get wrong
+    if (options.decrypt != null) {
+      if (!entry.isEncrypted()) {
+        throw new Error("options.decrypt can only be specified for encrypted entries");
+      }
+      if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
+      if (entry.isCompressed()) {
+        if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
+      }
+    }
+    if (options.decompress != null) {
+      if (!entry.isCompressed()) {
+        throw new Error("options.decompress can only be specified for compressed entries");
+      }
+      if (!(options.decompress === false || options.decompress === true)) {
+        throw new Error("invalid options.decompress value: " + options.decompress);
+      }
+    }
+    if (options.start != null || options.end != null) {
+      if (entry.isCompressed() && options.decompress !== false) {
+        throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
+      }
+      if (entry.isEncrypted() && options.decrypt !== false) {
+        throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
+      }
+    }
+    if (options.start != null) {
+      relativeStart = options.start;
+      if (relativeStart < 0) throw new Error("options.start < 0");
+      if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+    }
+    if (options.end != null) {
+      relativeEnd = options.end;
+      if (relativeEnd < 0) throw new Error("options.end < 0");
+      if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
+      if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+    }
+  }
+  // any further errors can either be caused by the zipfile,
+  // or were introduced in a minor version of yauzl,
+  // so should be passed to the client rather than thrown.
+  if (!self.isOpen) return callback(new Error("closed"));
+  if (entry.isEncrypted()) {
+    if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+  }
+  // make sure we don't lose the fd before we open the actual read stream
+  self.reader.ref();
+  var buffer = newBuffer(30);
+  readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+    try {
+      if (err) return callback(err);
+      // 0 - Local file header signature = 0x04034b50
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 0x04034b50) {
+        return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+      }
+      // all this should be redundant
+      // 4 - Version needed to extract (minimum)
+      // 6 - General purpose bit flag
+      // 8 - Compression method
+      // 10 - File last modification time
+      // 12 - File last modification date
+      // 14 - CRC-32
+      // 18 - Compressed size
+      // 22 - Uncompressed size
+      // 26 - File name length (n)
+      var fileNameLength = buffer.readUInt16LE(26);
+      // 28 - Extra field length (m)
+      var extraFieldLength = buffer.readUInt16LE(28);
+      // 30 - File name
+      // 30+n - Extra field
+      var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+      var decompress;
+      if (entry.compressionMethod === 0) {
+        // 0 - The file is stored (no compression)
+        decompress = false;
+      } else if (entry.compressionMethod === 8) {
+        // 8 - The file is Deflated
+        decompress = options.decompress != null ? options.decompress : true;
+      } else {
+        return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+      }
+      var fileDataStart = localFileHeaderEnd;
+      var fileDataEnd = fileDataStart + entry.compressedSize;
+      if (entry.compressedSize !== 0) {
+        // bounds check now, because the read streams will probably not complain loud enough.
+        // since we're dealing with an unsigned offset plus an unsigned size,
+        // we only have 1 thing to check for.
+        if (fileDataEnd > self.fileSize) {
+          return callback(new Error("file data overflows file bounds: " +
+              fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+        }
+      }
+      var readStream = self.reader.createReadStream({
+        start: fileDataStart + relativeStart,
+        end: fileDataStart + relativeEnd,
+      });
+      var endpointStream = readStream;
+      if (decompress) {
+        var destroyed = false;
+        var inflateFilter = zlib.createInflateRaw();
+        readStream.on("error", function(err) {
+          // setImmediate here because errors can be emitted during the first call to pipe()
+          setImmediate(function() {
+            if (!destroyed) inflateFilter.emit("error", err);
+          });
+        });
+        readStream.pipe(inflateFilter);
+
+        if (self.validateEntrySizes) {
+          endpointStream = new AssertByteCountStream(entry.uncompressedSize);
+          inflateFilter.on("error", function(err) {
+            // forward zlib errors to the client-visible stream
+            setImmediate(function() {
+              if (!destroyed) endpointStream.emit("error", err);
+            });
+          });
+          inflateFilter.pipe(endpointStream);
+        } else {
+          // the zlib filter is the client-visible stream
+          endpointStream = inflateFilter;
+        }
+        // this is part of yauzl's API, so implement this function on the client-visible stream
+        endpointStream.destroy = function() {
+          destroyed = true;
+          if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+          readStream.unpipe(inflateFilter);
+          // TODO: the inflateFilter may cause a memory leak. see Issue #27.
+          readStream.destroy();
+        };
+      }
+      callback(null, endpointStream);
+    } finally {
+      self.reader.unref();
+    }
+  });
+};
+
+function Entry() {
+}
+Entry.prototype.getLastModDate = function() {
+  return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
+};
+Entry.prototype.isEncrypted = function() {
+  return (this.generalPurposeBitFlag & 0x1) !== 0;
+};
+Entry.prototype.isCompressed = function() {
+  return this.compressionMethod === 8;
+};
+
+function dosDateTimeToDate(date, time) {
+  var day = date & 0x1f; // 1-31
+  var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11
+  var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108
+
+  var millisecond = 0;
+  var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers)
+  var minute = time >> 5 & 0x3f; // 0-59
+  var hour = time >> 11 & 0x1f; // 0-23
+
+  return new Date(year, month, day, hour, minute, second, millisecond);
+}
+
+function validateFileName(fileName) {
+  if (fileName.indexOf("\\") !== -1) {
+    return "invalid characters in fileName: " + fileName;
+  }
+  if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+    return "absolute path: " + fileName;
+  }
+  if (fileName.split("/").indexOf("..") !== -1) {
+    return "invalid relative path: " + fileName;
+  }
+  // all good
+  return null;
+}
+
+function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+  if (length === 0) {
+    // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file
+    return setImmediate(function() { callback(null, newBuffer(0)); });
+  }
+  reader.read(buffer, offset, length, position, function(err, bytesRead) {
+    if (err) return callback(err);
+    if (bytesRead < length) {
+      return callback(new Error("unexpected EOF"));
+    }
+    callback();
+  });
+}
+
+util.inherits(AssertByteCountStream, Transform);
+function AssertByteCountStream(byteCount) {
+  Transform.call(this);
+  this.actualByteCount = 0;
+  this.expectedByteCount = byteCount;
+}
+AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+  this.actualByteCount += chunk.length;
+  if (this.actualByteCount > this.expectedByteCount) {
+    var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+    return cb(new Error(msg));
+  }
+  cb(null, chunk);
+};
+AssertByteCountStream.prototype._flush = function(cb) {
+  if (this.actualByteCount < this.expectedByteCount) {
+    var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+    return cb(new Error(msg));
+  }
+  cb();
+};
+
+util.inherits(RandomAccessReader, EventEmitter);
+function RandomAccessReader() {
+  EventEmitter.call(this);
+  this.refCount = 0;
+}
+RandomAccessReader.prototype.ref = function() {
+  this.refCount += 1;
+};
+RandomAccessReader.prototype.unref = function() {
+  var self = this;
+  self.refCount -= 1;
 
-  XMLDOMImplementation = __webpack_require__(1770);
+  if (self.refCount > 0) return;
+  if (self.refCount < 0) throw new Error("invalid unref");
 
-  XMLDocument = __webpack_require__(6934);
+  self.close(onCloseDone);
 
-  XMLDocumentCB = __webpack_require__(9227);
+  function onCloseDone(err) {
+    if (err) return self.emit('error', err);
+    self.emit('close');
+  }
+};
+RandomAccessReader.prototype.createReadStream = function(options) {
+  var start = options.start;
+  var end = options.end;
+  if (start === end) {
+    var emptyStream = new PassThrough();
+    setImmediate(function() {
+      emptyStream.end();
+    });
+    return emptyStream;
+  }
+  var stream = this._readStreamForRange(start, end);
 
-  XMLStringWriter = __webpack_require__(6434);
+  var destroyed = false;
+  var refUnrefFilter = new RefUnrefFilter(this);
+  stream.on("error", function(err) {
+    setImmediate(function() {
+      if (!destroyed) refUnrefFilter.emit("error", err);
+    });
+  });
+  refUnrefFilter.destroy = function() {
+    stream.unpipe(refUnrefFilter);
+    refUnrefFilter.unref();
+    stream.destroy();
+  };
 
-  XMLStreamWriter = __webpack_require__(1996);
+  var byteCounter = new AssertByteCountStream(end - start);
+  refUnrefFilter.on("error", function(err) {
+    setImmediate(function() {
+      if (!destroyed) byteCounter.emit("error", err);
+    });
+  });
+  byteCounter.destroy = function() {
+    destroyed = true;
+    refUnrefFilter.unpipe(byteCounter);
+    refUnrefFilter.destroy();
+  };
 
-  NodeType = __webpack_require__(9335);
+  return stream.pipe(refUnrefFilter).pipe(byteCounter);
+};
+RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+  throw new Error("not implemented");
+};
+RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+  var readStream = this.createReadStream({start: position, end: position + length});
+  var writeStream = new Writable();
+  var written = 0;
+  writeStream._write = function(chunk, encoding, cb) {
+    chunk.copy(buffer, offset + written, 0, chunk.length);
+    written += chunk.length;
+    cb();
+  };
+  writeStream.on("finish", callback);
+  readStream.on("error", function(error) {
+    callback(error);
+  });
+  readStream.pipe(writeStream);
+};
+RandomAccessReader.prototype.close = function(callback) {
+  setImmediate(callback);
+};
 
-  WriterState = __webpack_require__(594);
+util.inherits(RefUnrefFilter, PassThrough);
+function RefUnrefFilter(context) {
+  PassThrough.call(this);
+  this.context = context;
+  this.context.ref();
+  this.unreffedYet = false;
+}
+RefUnrefFilter.prototype._flush = function(cb) {
+  this.unref();
+  cb();
+};
+RefUnrefFilter.prototype.unref = function(cb) {
+  if (this.unreffedYet) return;
+  this.unreffedYet = true;
+  this.context.unref();
+};
 
-  module.exports.create = function(name, xmldec, doctype, options) {
-    var doc, root;
-    if (name == null) {
-      throw new Error("Root element needs a name.");
-    }
-    options = assign({}, xmldec, doctype, options);
-    doc = new XMLDocument(options);
-    root = doc.element(name);
-    if (!options.headless) {
-      doc.declaration(options);
-      if ((options.pubID != null) || (options.sysID != null)) {
-        doc.dtd(options);
-      }
+var cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
+function decodeBuffer(buffer, start, end, isUtf8) {
+  if (isUtf8) {
+    return buffer.toString("utf8", start, end);
+  } else {
+    var result = "";
+    for (var i = start; i < end; i++) {
+      result += cp437[buffer[i]];
     }
-    return root;
-  };
+    return result;
+  }
+}
 
-  module.exports.begin = function(options, onData, onEnd) {
-    var ref1;
-    if (isFunction(options)) {
-      ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
-      options = {};
-    }
-    if (onData) {
-      return new XMLDocumentCB(options, onData, onEnd);
-    } else {
-      return new XMLDocument(options);
-    }
-  };
+function readUInt64LE(buffer, offset) {
+  // there is no native function for this, because we can't actually store 64-bit integers precisely.
+  // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore.
+  // but since 53 bits is a whole lot more than 32 bits, we do our best anyway.
+  var lower32 = buffer.readUInt32LE(offset);
+  var upper32 = buffer.readUInt32LE(offset + 4);
+  // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers.
+  return upper32 * 0x100000000 + lower32;
+  // as long as we're bounds checking the result of this function against the total file size,
+  // we'll catch any overflow errors, because we already made sure the total file size was within reason.
+}
 
-  module.exports.stringWriter = function(options) {
-    return new XMLStringWriter(options);
+// Node 10 deprecated new Buffer().
+var newBuffer;
+if (typeof Buffer.allocUnsafe === "function") {
+  newBuffer = function(len) {
+    return Buffer.allocUnsafe(len);
   };
-
-  module.exports.streamWriter = function(stream, options) {
-    return new XMLStreamWriter(stream, options);
+} else {
+  newBuffer = function(len) {
+    return new Buffer(len);
   };
+}
 
-  module.exports.implementation = new XMLDOMImplementation();
+function defaultCallback(err) {
+  if (err) throw err;
+}
 
-  module.exports.nodeType = NodeType;
 
-  module.exports.writerState = WriterState;
+/***/ }),
 
-}).call(this);
+/***/ 871:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("buffer");
+
+/***/ }),
+
+/***/ 6231:
+/***/ ((module) => {
 
+"use strict";
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 1423:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("path");
 
 /***/ }),
 
@@ -7104,6 +9727,22 @@ module.exports = require("string_decoder");
 "use strict";
 module.exports = require("timers");
 
+/***/ }),
+
+/***/ 6464:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("util");
+
+/***/ }),
+
+/***/ 8884:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("zlib");
+
 /***/ })
 
 /******/ 	});
@@ -7179,10 +9818,12 @@ __webpack_require__.d(__webpack_exports__, {
   "launchSimulator": () => (/* reexport */ launchSimulator)
 });
 
+;// CONCATENATED MODULE: external "crypto"
+const external_crypto_namespaceObject = require("crypto");
 ;// CONCATENATED MODULE: external "fs/promises"
 const promises_namespaceObject = require("fs/promises");
-;// CONCATENATED MODULE: external "path"
-const external_path_namespaceObject = require("path");
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(1423);
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: external "./sdk-util.cjs"
@@ -7238,7 +9879,7 @@ async function build_project(product, options, lineCallback) {
   if (product) {
     extraArgs.push("-d", simulatorBuild !== false ? `${product}_sim` : product);
   }
-  const exe = external_path_namespaceObject.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "monkeyc.bat" : "monkeyc");
+  const exe = external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "monkeyc.bat" : "monkeyc");
   const args = [
     ["-o", program],
     ["-f", jungleFiles],
@@ -7251,12 +9892,14 @@ async function build_project(product, options, lineCallback) {
     (line) => console.error(line),
   ];
   return returnCommand
-    ? { exe, args }
+    ? { exe, args, program: external_path_.resolve(workspace, program), product }
     : (0,external_util_cjs_namespaceObject.spawnByLine)(exe, args, handlers, {
         cwd: workspace,
       });
 }
 
+// EXTERNAL MODULE: ./node_modules/extract-zip/index.js
+var extract_zip = __webpack_require__(2106);
 // EXTERNAL MODULE: ./node_modules/xml2js/lib/xml2js.js
 var xml2js = __webpack_require__(5055);
 ;// CONCATENATED MODULE: ./build/jungle.js
@@ -7281,12 +9924,47 @@ function manifestProducts(manifest) {
   const app =
     manifest["iq:manifest"]["iq:application"] ||
     manifest["iq:manifest"]["iq:barrel"];
-  return app[0]["iq:products"][0]["iq:product"]
+  return ((app[0]["iq:products"] || [{}])[0]["iq:product"] || [])
     .map((p) => p.$.id)
     .sort()
     .filter((p, i, a) => !i || p !== a[i - 1]);
 }
 
+function manifestBarrels(manifest) {
+  const app = manifest["iq:manifest"]["iq:application"];
+  if (
+    Array.isArray(app) &&
+    app.length &&
+    app[0] &&
+    Array.isArray(app[0]["iq:barrels"]) &&
+    app[0]["iq:barrels"].length &&
+    Array.isArray(app[0]["iq:barrels"][0]["iq:depends"])
+  ) {
+    return app[0]["iq:barrels"][0]["iq:depends"]
+      .map((p) => p.$.name)
+      .sort()
+      .filter((p, i, a) => !i || p !== a[i - 1]);
+  }
+  return [];
+}
+
+function manifestDropBarrels(manifest) {
+  delete manifest["iq:manifest"]["iq:application"][0]["iq:barrels"];
+}
+
+function manifestBarrelName(manifestName, manifest) {
+  const barrel = manifest["iq:manifest"]["iq:barrel"];
+  if (!barrel) throw new Error(`Not a barrel manifest: ${manifestName}`);
+  return barrel[0].$.module;
+}
+
+function manifestAnnotations(manifest) {
+  const barrel = manifest["iq:manifest"]["iq:barrel"];
+  if (!barrel) return null;
+  const annotations = barrel[0]["iq:annotations"];
+  return annotations && annotations[0]["iq:annotation"];
+}
+
 async function checkManifest(manifest, products) {
   let ok = true;
   if (!manifest["iq:manifest"]["$"]["xmlns:iq"]) {
@@ -7303,13 +9981,14 @@ async function checkManifest(manifest, products) {
     ok = false;
     elm.$.id = "08070f9d-8b4e-40a4-9c49-fe67a2a55dec";
   }
-  const type = elm.$.type.replace(/-/, "").toLowerCase();
+  const type = elm.$.type.replace(/-/g, "").toLowerCase();
   const deviceInfo = await (0,external_sdk_util_cjs_namespaceObject.getDeviceInfo)();
   const allowedProducts = products.sort().filter(
     (p) =>
       deviceInfo[p] &&
       deviceInfo[p].appTypes.find((at) => {
-        return at.type.toLowerCase() === type;
+        const t = at.type.toLowerCase();
+        return t === type || `${t}app` === type;
       })
   );
   if (
@@ -7350,6 +10029,8 @@ async function checkManifest(manifest, products) {
 
 
 
+
+
 async function default_jungle() {
   const assignments = [];
   const devices = await (0,external_sdk_util_cjs_namespaceObject.getDeviceInfo)();
@@ -7597,8 +10278,8 @@ function resolve_node(state, node) {
 
 function resolve_filename(literal, default_source) {
   if (typeof literal === "string") return literal;
-  const root = external_path_namespaceObject.dirname(literal.source || default_source);
-  return external_path_namespaceObject.resolve(root, literal.value);
+  const root = external_path_.dirname(literal.source || default_source);
+  return external_path_.resolve(root, literal.value);
 }
 
 async function resolve_literals(qualifier, default_source) {
@@ -7655,23 +10336,36 @@ async function resolve_literals(qualifier, default_source) {
     base[name] = literals.map((v) => v.value);
   };
   resolve_literal_list(qualifier, "excludeAnnotations");
-  resolve_literal_list(qualifier, "annotations");
+  // turn the annotations inside out.
+  // in the jungle we have
+  //   qualifier.BarrelName.annotations = Foo;Bar
+  // but its more convenient as
+  //   qualifier.annotations.BarrelName = Foo;Bar
+  const annotations = {};
+  Object.entries(qualifier).forEach(([k, v]) => {
+    if ((0,external_api_cjs_namespaceObject.hasProperty)(v, "annotations")) {
+      annotations[k] = v.annotations;
+      resolve_literal_list(annotations, k);
+      delete qualifier[k];
+    }
+  });
+  qualifier.annotations = annotations;
 }
 
 async function find_build_instructions_in_resource(file) {
   const data = await promises_namespaceObject.readFile(file);
   const rez = await (0,xml2js.parseStringPromise)(data).catch(() => ({}));
   if (rez.build && rez.build.exclude) {
-    const dir = external_path_namespaceObject.dirname(file);
+    const dir = external_path_.dirname(file);
     const sourceExcludes = rez.build.exclude
       .map((e) => e.$.file)
       .filter((f) => f != null)
-      .map((f) => external_path_namespaceObject.resolve(dir, f).replace(/\\/g, "/"));
+      .map((f) => external_path_.resolve(dir, f).replace(/\\/g, "/"));
 
     const filePatterns = rez.build.exclude
       .map((e) => e.$.dir)
       .filter((f) => f != null)
-      .map((f) => external_path_namespaceObject.join(dir, f, "**", "*.mc").replace(/\\/g, "/"));
+      .map((f) => external_path_.join(dir, f, "**", "*.mc").replace(/\\/g, "/"));
     if (filePatterns.length) {
       const files = (
         await Promise.all(filePatterns.map((p) => (0,external_util_cjs_namespaceObject.globa)(p)))
@@ -7795,6 +10489,7 @@ function identify_optimizer_groups(targets, options) {
       sourcePath,
       sourceExcludes,
       barrelPath,
+      barrelMap,
       excludeAnnotations,
       annotations,
     } = target.qualifier;
@@ -7804,9 +10499,11 @@ function identify_optimizer_groups(targets, options) {
         ignoredExcludeAnnotations
       );
     }
-    if (annotations && ignoredAnnotations) {
-      annotations = getStrsWithIgnore(annotations, ignoredAnnotations);
-    }
+    Object.entries(annotations).forEach(([key, value]) => {
+      if (ignoredAnnotations) {
+        annotations[key] = getStrsWithIgnore(value, ignoredAnnotations);
+      }
+    });
     if (ignoredSourcePaths) {
       sourcePath = sourcePath
         .map((path) => Object.keys(ignoredSourcePaths[path]))
@@ -7818,6 +10515,7 @@ function identify_optimizer_groups(targets, options) {
       sourcePath,
       sourceExcludes,
       barrelPath,
+      barrelMap,
       excludeAnnotations,
       annotations,
     };
@@ -7837,11 +10535,248 @@ function identify_optimizer_groups(targets, options) {
   });
 }
 
-async function get_jungle(jungles, options) {
-  options = options || {};
-  jungles = jungles
+/**
+ * Find the barrels referred to by barrelPath.
+ *
+ * Each string in barrelPath is a glob that can expand to a
+ * .jungle file, a .barrel file, or a directory. If it
+ * expands to a directory, that directory is searched recursively
+ * for .barrel files.
+ *
+ * @param {string|string[]} barrelPath the path or paths to search
+ * @returns {Promise<string[]>}
+ */
+function find_barrels(barrelPath) {
+  if (Array.isArray(barrelPath)) {
+    // This is a sublist. The barrel has more than one jungle file.
+    return Promise.all(
+      barrelPath.map((path) => (0,external_util_cjs_namespaceObject.globa)(path, { mark: true }))
+    ).then((paths) => [
+      paths
+        .flat()
+        .filter((path) => path.endsWith(".jungle"))
+        .join(";"),
+    ]);
+  }
+  return (0,external_util_cjs_namespaceObject.globa)(barrelPath, { mark: true })
+    .then((paths) =>
+      Promise.all(
+        paths.map((path) =>
+          path.endsWith("/") ? (0,external_util_cjs_namespaceObject.globa)(`${path}**/*.barrel`) : path
+        )
+      )
+    )
+    .then((barrelPaths) =>
+      barrelPaths
+        .flat()
+        .filter((path) => path.endsWith(".jungle") || path.endsWith(".barrel"))
+    );
+}
+
+/**
+ *@typedef {Object} Target - Build instructions for a particular product in a jungle
+ *
+ * @typedef {Object} JungleInfoBase - The result of parsing a jungle file, without resolving any products
+ * @property {string[]} jungles - Paths to the barrel's jungle files
+ * @property {string} manifest - Path to the barrel's manifest file
+ * @property {Object} xml - The xml content of the manifest, as returned by xml2js
+ * @property {string[]=} annotations - Array of annotations supported by this barrel
+ *
+ * @typedef {Object} PartialJungle - Used to extend JungleInfoBase to ResolvedJungle
+ * @property {Target[]} targets - All of the supported targets in the manifest
+ *
+ * @typedef {Object} PartialBarrel - Used to extend JungleInfoBase to ResolvedBarrel
+ * @property {JungleQualifier} qualifier - the qualifier for this PartialBarrel's target
+ *
+ * @typedef {JungleInfoBase & PartialJungle} ResolvedJungle - The result of parsing an application's jungle file
+ * @typedef {JungleInfoBase & PartialBarrel} ResolvedBarrel - The result of parsing a barrel's jungle file for a particular product
+ *
+ * @typedef {Object} JungleQualifier
+ * @property {string[]=} sourcePath - locations to find source file
+ * @property {string[]=} sourceExcludes - array of files to exclude from the build (from resource build instructions)
+ * @property {string[]=} excludeAnnotations - array of excludeAnnotations
+ * @property {string[]=} resourcePath - locations to find resource files
+ * @property {LangResourcePaths} lang - locations to find resource files
+ * @property {(string|string[])[]=} barrelPath - locations to find barrels
+ * @property {BarrelAnnotations=} annotations - map from barrel names to arrays of annotations
+ * @property {BarrelMap=} barrelMap
+ *
+ * @typedef {{[key:string]:string[]}} LangResourcePaths - Map from language codes to the corresponding resource paths
+ * @typedef {{[key:string]:string[]}} BarrelAnnotations - Map from barrel name to imported annotations
+ * @typedef {{[key:string]:ResolvedBarrel}} BarrelMap - Map from barrel name to the set of resolved barrel projects for that name. Note that they must all share a manifest.
+ */
+
+/**
+ * Given a .barrel file, unpack it into barrelDir, then process its .jungle file as below
+ * Given a .jungle file, resolve it to a ResolvedJungle
+ *
+ * @param {string} barrel Path to a .jungle or .barrel file to resolve
+ * @param {string} barrelDir Directory where .barrel files should be unpacked
+ * @param {string[]} products The products supported by the importing project
+ * @param {*} options
+ * @returns {Promise<ResolvedJungle>}
+ */
+function resolve_barrel(barrel, barrelDir, products, options) {
+  const cache = options._cache;
+  if ((0,external_api_cjs_namespaceObject.hasProperty)(cache.barrels, barrel)) {
+    return cache.barrels[barrel];
+  }
+  let promise = Promise.resolve();
+  let rawBarrel = barrel;
+  if (barrel.endsWith(".barrel")) {
+    // A barrel with the given name could in theory resolve to a different physical
+    // barrel file for each product, so uniqify the local name with a sha1.
+    const sha1 = external_crypto_namespaceObject.createHash("sha1")
+      .update(barrel, "binary")
+      .digest("base64")
+      .replace(/[\/=+]/g, "");
+    const localPath = external_path_.resolve(
+      barrelDir,
+      `${external_path_.basename(barrel, ".barrel")}-${sha1}`
+    );
+    rawBarrel = external_path_.resolve(localPath, "barrel.jungle");
+    promise = promise.then(() =>
+      promises_namespaceObject.stat(localPath)
+        .then(
+          (localStat) =>
+            !localStat.isDirectory() ||
+            promises_namespaceObject.stat(barrel)
+              .then((barrelStat) => localStat.mtimeMs < barrelStat.mtimeMs),
+          () => true
+        )
+        .then(
+          (needsUpdate) =>
+            needsUpdate &&
+            promises_namespaceObject.rm(localPath, { recursive: true, force: true })
+              .then(() => extract_zip(barrel, { dir: localPath }))
+        )
+    );
+  }
+  return promise
+    .then(() => get_jungle_and_barrels(rawBarrel, products, options))
+    .then((result) => {
+      if (!cache.barrels) cache.barrels = {};
+      return (cache.barrels[barrel] = { ...result });
+    });
+}
+
+/**
+ * Find and resolve the BarrelMap for product, and add it to qualifier.
+ *
+ * @param {string} product The device id we're resolving
+ * @param {JungleQualifier} qualifier The qualifier for product from the main jungle
+ * @param {string[]} barrels The barrels imported by the project's manifest
+ * @param {string[]} products The products supported by the importing project (used when the barrel project has none)
+ * @param {*} options
+ * @returns {Promise<void>}
+ */
+function resolve_barrels(product, qualifier, barrels, products, options) {
+  if (qualifier.annotations) {
+    Object.keys(qualifier.annotations).forEach((key) => {
+      // delete annotations for non-existent barrels such as
+      if (!barrels.includes(key)) {
+        delete qualifier.annotations[key];
+      }
+    });
+  }
+  if (!barrels.length) {
+    delete qualifier.barrelPath;
+    return;
+  }
+  const cache = options._cache || (options._cache = {});
+  const barrelMapKey = JSON.stringify([barrels, qualifier.barrelPath]);
+  const setBarrelMap = (barrelMap) => {
+    qualifier.barrelMap = barrels.reduce((result, barrel) => {
+      const { targets, ...rest } = barrelMap[barrel];
+      const target = targets.find((t) => t.product === product);
+      if (!target) {
+        throw new Error(`Barrel ${barrel} does not support device ${product}`);
+      }
+      rest.qualifier = target.qualifier;
+      result[barrel] = rest;
+      return result;
+    }, {});
+  };
+  if ((0,external_api_cjs_namespaceObject.hasProperty)(cache.barrelMap, barrelMapKey)) {
+    setBarrelMap(cache.barrelMap[barrelMapKey]);
+    return;
+  }
+  const barrelDir = external_path_.resolve(
+    options.workspace,
+    options.outputPath,
+    "raw-barrels"
+  );
+  const barrelMap = Object.fromEntries(barrels.map((b) => [b, null]));
+  return (qualifier.barrelPath || [])
+    .reduce(
+      (promise, barrelPath) =>
+        promise
+          .then(() => find_barrels(barrelPath))
+          .then((barrelPaths) => {
+            return Promise.all(
+              barrelPaths.map((barrel) =>
+                resolve_barrel(barrel, barrelDir, products, options)
+              )
+            );
+          })
+          .then((resolvedBarrels) => {
+            resolvedBarrels.forEach((resolvedBarrel) => {
+              const name = manifestBarrelName(
+                resolvedBarrel.manifest,
+                resolvedBarrel.xml
+              );
+              if (!(0,external_api_cjs_namespaceObject.hasProperty)(barrelMap, name)) return;
+              if (barrelMap[name]) {
+                const bname = (r) => r.jungles.join(";");
+                throw new Error(
+                  `Barrel ${name} already resolved to ${bname(
+                    barrelMap[name]
+                  )}; can't also resolve to ${bname(resolvedBarrel)}`
+                );
+              }
+              barrelMap[name] = resolvedBarrel;
+            });
+          }),
+      Promise.resolve()
+    )
+    .then(() => {
+      const unresolved = Object.entries(barrelMap).filter((v) => v[1] === null);
+      if (unresolved.length) {
+        throw new Error(
+          `Failed to resolve some barrels: ${unresolved
+            .map(([name]) => name)
+            .join(",")}`
+        );
+      }
+      if (!cache.barrelMap) cache.barrelMap = {};
+      cache.barrelMap[barrelMapKey] = barrelMap;
+      setBarrelMap(barrelMap);
+    });
+}
+/**
+ *
+ * @param {string} jungleFiles Semicolon separated list of jungle files
+ * @param {string[]} defaultProducts Default set of products. Only used by a barrel with no products of its own
+ * @param {*} options
+ * @returns {Promise<ResolvedJungle>}
+ */
+async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
+  const jungles = jungleFiles
     .split(";")
-    .map((jungle) => external_path_namespaceObject.resolve(options.workspace || "./", jungle));
+    .map((jungle) => external_path_.resolve(options.workspace || "./", jungle));
+  const barrels_jungle = external_path_.resolve(
+    external_path_.dirname(jungles[0]),
+    "barrels.jungle"
+  );
+  if (!jungles.includes(barrels_jungle)) {
+    if (
+      await promises_namespaceObject.stat(barrels_jungle)
+        .then((s) => s.isFile())
+        .catch(() => false)
+    ) {
+      jungles.push(barrels_jungle);
+    }
+  }
   const state = await process_jungles(jungles);
   // apparently square_watch is an alias for rectangle_watch
   state["square_watch"] = state["rectangle_watch"];
@@ -7851,17 +10786,29 @@ async function get_jungle(jungles, options) {
   );
   if (!manifest_node) throw new Error("No manifest found!");
   const manifest = resolve_filename(manifest_node[0]);
+  if (!options.workspace) {
+    options.workspace = external_path_.dirname(manifest);
+  }
   const xml = await readManifest(manifest);
   const targets = [];
+  const barrels = manifestBarrels(xml);
+  const annotations = manifestAnnotations(xml);
+  const products = manifestProducts(xml);
+  if (products.length === 0) products.push(...defaultProducts);
   let promise = Promise.resolve();
   const add_one = (product, shape) => {
     const qualifier = resolve_node(state, state[product]);
     if (!qualifier) return;
     promise = promise
       .then(() => resolve_literals(qualifier, manifest))
-      .then(() => targets.push({ product, qualifier, shape }));
+      .then(() =>
+        resolve_barrels(product, qualifier, barrels, products, options)
+      )
+      .then(() => {
+        targets.push({ product, qualifier, shape });
+      });
   };
-  manifestProducts(xml).forEach((product) => {
+  products.forEach((product) => {
     if ((0,external_api_cjs_namespaceObject.hasProperty)(state, product) && state[product].products) {
       // this was something like round_watch. Add all the corresponding
       // products.
@@ -7872,8 +10819,14 @@ async function get_jungle(jungles, options) {
   });
   await promise;
   await find_build_instructions(targets);
-  identify_optimizer_groups(targets, options);
-  return { manifest, targets, xml };
+  return { manifest, targets, xml, annotations, jungles };
+}
+
+async function get_jungle(jungles, options) {
+  options = options || {};
+  const result = await get_jungle_and_barrels(jungles, [], options);
+  identify_optimizer_groups(result.targets, options);
+  return result;
 }
 
 ;// CONCATENATED MODULE: external "child_process"
@@ -7883,15 +10836,24 @@ const external_child_process_namespaceObject = require("child_process");
 
 
 
+
 function launchSimulator() {
   return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => {
     const child = (0,external_child_process_namespaceObject.execFile)(
-      external_path_namespaceObject.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq")
+      external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq")
     );
     child.unref();
   });
 }
 
+function simulateProgram(prg, device) {
+  return getSdkPath().then((sdk) =>
+    spawnByLine(path.resolve(sdk, "bin", "monkeydo"), [prg, device], (line) =>
+      console.log(line)
+    )
+  );
+}
+
 ;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
 const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
 ;// CONCATENATED MODULE: ./src/mc-rewrite.js
@@ -7948,12 +10910,8 @@ function collectClassInfo(state) {
   });
 }
 
-async function analyze(fileNames, buildConfig) {
-  const excludeAnnotations =
-    buildConfig && buildConfig.excludeAnnotations
-      ? Object.fromEntries(buildConfig.excludeAnnotations.map((a) => [a, true]))
-      : {};
-
+async function analyze(fnMap) {
+  let excludeAnnotations;
   const allImports = [];
   const state = {
     allFunctions: [],
@@ -7961,11 +10919,11 @@ async function analyze(fileNames, buildConfig) {
     shouldExclude(node) {
       if (node.attrs && node.attrs.attrs) {
         if (
-          node.attrs.attrs.filter((attr) => {
+          node.attrs.attrs.some((attr) => {
             if (attr.type != "UnaryExpression") return false;
             if (attr.argument.type != "Identifier") return false;
             return (0,external_api_cjs_namespaceObject.hasProperty)(excludeAnnotations, attr.argument.name);
-          }).length
+          })
         ) {
           return true;
         }
@@ -8008,25 +10966,29 @@ async function analyze(fileNames, buildConfig) {
   };
   markApi(state.stack[0]);
 
+  const getAst = (source, monkeyCSource, exclude) => {
+    excludeAnnotations = exclude;
+    const ast = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc.parse(monkeyCSource, {
+      grammarSource: source,
+    });
+    ast.source = source;
+    ast.monkeyCSource = monkeyCSource;
+    (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+    return ast;
+  };
   const files = await Promise.all(
-    fileNames.map(async (name) => ({
-      name,
-      monkeyCSource: (await promises_namespaceObject.readFile(name))
-        .toString()
-        .replace(/\r\n/g, "\n"),
-    }))
+    Object.entries(fnMap).map(([name, { excludeAnnotations }]) =>
+      promises_namespaceObject.readFile(name).then((data) => ({
+        name,
+        ast: getAst(
+          name,
+          data.toString().replace(/\r\n/g, "\n"),
+          excludeAnnotations
+        ),
+      }))
+    )
   );
 
-  files.forEach((f) => {
-    f.ast = prettier_plugin_monkeyc_namespaceObject.parsers.monkeyc.parse(f.monkeyCSource, {
-      grammarSource: f.name,
-    });
-    f.ast.source = f.name;
-    f.ast.monkeyCSource = f.monkeyCSource;
-    delete f.monkeyCSource;
-    (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
-  });
-
   delete state.shouldExclude;
   delete state.post;
 
@@ -8247,8 +11209,8 @@ function evaluateFunction(func, args) {
   }
 }
 
-async function optimizeMonkeyC(fileNames, buildConfig) {
-  const { files, state } = await analyze(fileNames, buildConfig);
+async function optimizeMonkeyC(fnMap) {
+  const { files, state } = await analyze(fnMap);
   const replace = (node, obj) => {
     for (const k of Object.keys(node)) {
       delete node[k];
@@ -8655,6 +11617,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
 
 
 
+
 function relative_path_no_dotdot(relative) {
   return relative.replace(
     /^(\.\.[\\\/])+/,
@@ -8721,35 +11684,121 @@ async function buildOptimizedProject(product, options) {
   if (product) {
     product = config.products[0];
     if (config.simulatorBuild === false) {
-      bin = external_path_namespaceObject.join(bin, product);
+      bin = external_path_.join(bin, product);
     }
   } else {
-    bin = external_path_namespaceObject.join(bin, "exported");
+    bin = external_path_.join(bin, "exported");
     name = `${program}.iq`;
   }
-  config.program = external_path_namespaceObject.join(bin, name);
+  config.program = external_path_.join(bin, name);
   return build_project(product, config);
 }
 
+/**
+ * For each barrel project included in the build, we want to build
+ * a local barrel project inside the optimized directory.
+ *
+ * Note that for each named barrel, each target could include a
+ * different barrel, or barrel project. It could even include more
+ * than one - but in that case, they should be separate jungle files
+ * with the same manifest file.
+ *
+ * So for each input barrel (resolvedBarrel.jungles are the jungle
+ * files corresponding to an input barrel), we create a copy of
+ * the barrel with all the sources removed (and pick up the sources
+ * from the input barrel)
+ */
+async function createLocalBarrels(targets, options) {
+  if (
+    targets.every(
+      (target) =>
+        !target.group.optimizerConfig.barrelMap ||
+        Object.values(target.group.optimizerConfig.barrelMap).every(
+          (resolvedBarrel) => !resolvedBarrel.qualifier.resourcePath
+        )
+    )
+  ) {
+    // there are no barrels, or every barrel has no resources.
+    // we can drop any barrels altogether (we'll need to drop them
+    // from the manifest file too).
+    return;
+  }
+  // where to create the local barrel projects.
+  const barrelDir = external_path_.resolve(
+    options.workspace,
+    options.outputPath,
+    "opt-barrels"
+  );
+  return targets.reduce((promise, target) => {
+    const barrelMap = target.group.optimizerConfig.barrelMap;
+    if (!barrelMap || target.group.optBarrels) {
+      return promise;
+    }
+    const optBarrels = (target.group.optimizerConfig.optBarrels = {});
+    return Object.entries(barrelMap).reduce(
+      (promise, [barrel, resolvedBarrel]) => {
+        const { manifest, jungles } = resolvedBarrel;
+        const rawBarrelDir = external_path_.dirname(jungles[0]);
+        const rawJungles = jungles.map((jungle) =>
+          external_path_.relative(rawBarrelDir, jungle)
+        );
+        const sha1 = external_crypto_namespaceObject.createHash("sha1")
+          .update(rawBarrelDir, "binary")
+          .digest("base64")
+          .replace(/[\/=+]/g, "");
+        const optBarrelDir = external_path_.resolve(barrelDir, `${barrel}-${sha1}`);
+        if (!(0,external_api_cjs_namespaceObject.hasProperty)(optBarrels, barrel)) {
+          optBarrels[barrel] = {
+            rawBarrelDir,
+            manifest,
+            jungleFiles: [...rawJungles],
+            optBarrelDir,
+          };
+          return promise.then(() =>
+            (0,external_util_cjs_namespaceObject.copyRecursiveAsNeeded)(
+              rawBarrelDir,
+              optBarrelDir,
+              (src) => !src.endsWith(".mc")
+            )
+          );
+        }
+        if (
+          optBarrels[barrel].manifest !== manifest ||
+          optBarrels[barrel].optBarrelDir !== optBarrelDir ||
+          optBarrels[barrel].rawBarrelDir != rawBarrelDir
+        ) {
+          throw new Error(
+            `For device ${
+              target.product
+            }, barrel ${barrel} was mapped to both ${external_path_.relative(
+              optBarrels[barrel].rawBarrelDir,
+              optBarrels[barrel].manifest
+            )} in ${optBarrels[barrel].rawBarrelDir} and ${external_path_.relative(
+              rawBarrelDir,
+              manifest
+            )} in ${rawBarrelDir}.`
+          );
+        }
+        optBarrels[barrel].jungleFiles.push(...rawJungles);
+        return promise;
+      },
+      promise
+    );
+  }, Promise.resolve());
+}
+
 async function generateOptimizedProject(options) {
   const config = await getConfig(options);
   const workspace = config.workspace;
 
-  const jungleFiles = config.jungleFiles.split(";");
-  if (!jungleFiles.includes("barrels.jungle")) {
-    const barrels = external_path_namespaceObject.resolve(workspace, "barrels.jungle");
-    if (
-      await promises_namespaceObject.stat(barrels)
-        .then((s) => s.isFile())
-        .catch(() => false)
-    ) {
-      jungleFiles.push(barrels);
-    }
-  }
-  const { manifest, targets, xml } = await get_jungle(
-    jungleFiles.join(";"),
+  const { manifest, targets, xml, jungles } = await get_jungle(
+    config.jungleFiles,
     config
   );
+
+  const dependencyFiles = [manifest, ...jungles];
+  await createLocalBarrels(targets, options);
+
   const buildConfigs = {};
   const products = {};
   let pick_one = config.products ? config.products.indexOf("pick-one") : -1;
@@ -8759,25 +11808,24 @@ async function generateOptimizedProject(options) {
       options.products[pick_one] = targets[0].product;
     }
     return {
-      jungleFiles: jungleFiles.join(";"),
-      program: external_path_namespaceObject.basename(external_path_namespaceObject.dirname(manifest)),
+      jungleFiles: config.jungleFiles,
+      program: external_path_.basename(external_path_.dirname(manifest)),
     };
   }
+  let dropBarrels = false;
   const configKey = (p) =>
     p.group.key + (config.releaseBuild ? "-release" : "-debug");
   targets.forEach((p) => {
     const key = configKey(p);
     if (!(0,external_api_cjs_namespaceObject.hasProperty)(buildConfigs, key)) {
       p.group.dir = key;
-      buildConfigs[key] = null;
-      if (p.group.optimizerConfig["excludeAnnotations"] == null) {
-        p.group.optimizerConfig["excludeAnnotations"] = [];
+      if (
+        p.group.optimizerConfig.barrelMap &&
+        !p.group.optimizerConfig.optBarrels
+      ) {
+        dropBarrels = true;
       }
-      // Note that we exclude (:debug) in release builds, and we
-      // exclude (:release) in debug builds. This isn't backwards!
-      p.group.optimizerConfig["excludeAnnotations"].push(
-        config.releaseBuild ? "debug" : "release"
-      );
+      buildConfigs[key] = null;
     }
     if (
       pick_one >= 0 ||
@@ -8802,27 +11850,29 @@ async function generateOptimizedProject(options) {
 
   // console.log(JSON.stringify(targets));
 
-  const jungle_dir = external_path_namespaceObject.resolve(workspace, config.outputPath);
+  const jungle_dir = external_path_.resolve(workspace, config.outputPath);
   await promises_namespaceObject.mkdir(jungle_dir, { recursive: true });
-  const relative_path = (s) => external_path_namespaceObject.relative(jungle_dir, s);
+  const relative_path = (s) => external_path_.relative(jungle_dir, s);
   let relative_manifest = relative_path(manifest);
   const manifestOk =
-    !config.checkManifest ||
-    (await checkManifest(
-      xml,
-      targets.map((t) => t.product)
-    ));
+    (!config.checkManifest ||
+      (await checkManifest(
+        xml,
+        targets.map((t) => t.product)
+      ))) &&
+    !dropBarrels;
   const promises = Object.keys(buildConfigs)
     .sort()
     .map((key) => {
       const buildConfig = buildConfigs[key];
-      const outputPath = external_path_namespaceObject.join(config.outputPath, key);
+      const outputPath = external_path_.join(config.outputPath, key);
 
       return buildConfig
         ? generateOneConfig({
             ...config,
             buildConfig,
             outputPath,
+            dependencyFiles,
           }).catch((e) => {
             if (!e.stack) {
               e = new Error(e.toString());
@@ -8830,14 +11880,17 @@ async function generateOptimizedProject(options) {
             e.products = products[key];
             throw e;
           })
-        : promises_namespaceObject.rm(external_path_namespaceObject.resolve(workspace, outputPath), {
+        : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
             recursive: true,
             force: true,
           });
     });
 
   if (!manifestOk) {
-    const manifestFile = external_path_namespaceObject.join(jungle_dir, "manifest.xml");
+    if (dropBarrels) {
+      manifestDropBarrels(xml);
+    }
+    const manifestFile = external_path_.join(jungle_dir, "manifest.xml");
     promises.push(writeManifest(manifestFile, xml));
     relative_manifest = "manifest.xml";
   }
@@ -8855,12 +11908,46 @@ async function generateOptimizedProject(options) {
     const { product, qualifier, group } = jungle;
     const prefix = `${product}.`;
     process_field(prefix, qualifier, "sourcePath", (s) =>
-      external_path_namespaceObject.join(group.dir, relative_path_no_dotdot(external_path_namespaceObject.relative(workspace, s)))
+      external_path_.join(
+          group.dir,
+          "source",
+          relative_path_no_dotdot(external_path_.relative(workspace, s))
+        )
         .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1")
     );
+    if (group.optimizerConfig.optBarrels) {
+      parts.push(
+        `${prefix}barrelPath = ${Object.values(group.optimizerConfig.optBarrels)
+          .map(
+            (value) =>
+              `[${value.jungleFiles
+                .map((j) => relative_path(external_path_.join(value.optBarrelDir, j)))
+                .join(";")}]`
+          )
+          .join(";")}`
+      );
+    }
+    if (group.optimizerConfig.barrelMap) {
+      parts.push(
+        `${prefix}sourcePath = ${[`$(${prefix}sourcePath)`]
+          .concat(
+            Object.entries(group.optimizerConfig.barrelMap)
+              .map(([barrel, resolvedBarrel]) => {
+                const root = external_path_.dirname(resolvedBarrel.jungles[0]);
+                return (resolvedBarrel.qualifier.sourcePath || []).map((s) =>
+                  external_path_.join(group.dir, "barrels", barrel, external_path_.relative(root, s))
+                    .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1")
+                );
+              })
+              .flat()
+              .sort()
+              .filter((s, i, arr) => !i || s !== arr[i - 1])
+          )
+          .join(";")}`
+      );
+    }
+    // annotations were handled via source transformations.
     process_field(prefix, qualifier, "resourcePath", relative_path);
-    process_field(prefix, qualifier, "barrelPath", relative_path);
-    process_field(prefix, qualifier, "annotations");
     process_field(prefix, qualifier, "excludeAnnotations");
     if (qualifier.lang) {
       Object.keys(qualifier.lang).forEach((key) => {
@@ -8869,23 +11956,25 @@ async function generateOptimizedProject(options) {
     }
   });
 
-  const outputJungle = external_path_namespaceObject.join(
+  const jungleFiles = external_path_.join(
     jungle_dir,
     `${config.releaseBuild ? "release" : "debug"}.jungle`
   );
-  promises.push(promises_namespaceObject.writeFile(outputJungle, parts.join("\n")));
+  promises.push(promises_namespaceObject.writeFile(jungleFiles, parts.join("\n")));
 
   await Promise.all(promises);
   return {
-    jungleFiles: outputJungle,
-    program: external_path_namespaceObject.basename(external_path_namespaceObject.dirname(manifest)),
+    jungleFiles,
+    program: external_path_.basename(external_path_.dirname(manifest)),
   };
 }
 
-async function generateOneConfig(config) {
-  const { workspace, buildConfig } = config;
-  const output = external_path_namespaceObject.join(workspace, config.outputPath);
-
+async function fileInfoFromConfig(
+  workspace,
+  output,
+  buildConfig,
+  extraExcludes
+) {
   const paths = (
     await Promise.all(
       buildConfig.sourcePath.map((pattern) =>
@@ -8906,24 +11995,94 @@ async function generateOneConfig(config) {
     .flat()
     .filter(
       (file) =>
-        !file.endsWith("/") &&
+        file.endsWith(".mc") &&
+        !external_path_.relative(workspace, file).startsWith("bin") &&
         (!buildConfig.sourceExcludes ||
           !buildConfig.sourceExcludes.includes(file))
-    )
-    .map((file) => external_path_namespaceObject.relative(workspace, file))
-    .filter((file) => !file.startsWith("bin"));
-
-  const fnMap = Object.fromEntries(
-    files
-      .filter((src) => /\.mc$/.test(src))
-      .map((file) => [
-        external_path_namespaceObject.join(workspace, file),
-        external_path_namespaceObject.join(output, relative_path_no_dotdot(file)),
-      ])
+    );
+
+  const excludeAnnotations = Object.assign(
+    buildConfig.excludeAnnotations
+      ? Object.fromEntries(
+          buildConfig.excludeAnnotations.map((ex) => [ex, true])
+        )
+      : {},
+    extraExcludes
+  );
+
+  return Object.fromEntries(
+    files.map((file) => [
+      file,
+      {
+        output: external_path_.join(
+          output,
+          relative_path_no_dotdot(external_path_.relative(workspace, file))
+        ),
+        excludeAnnotations,
+      },
+    ])
+  );
+}
+
+function excludesFromAnnotations(barrel, annotations, resolvedBarrel) {
+  const excludes = resolvedBarrel.annotations
+    ? Object.fromEntries(resolvedBarrel.annotations.map((a) => [a, true]))
+    : {};
+  if (annotations && annotations[barrel]) {
+    annotations[barrel].forEach((a) => {
+      delete excludes[a];
+    });
+  }
+  return excludes;
+}
+
+async function generateOneConfig(config) {
+  const { workspace, buildConfig } = config;
+  const output = external_path_.join(workspace, config.outputPath);
+
+  const dependencyFiles = [...config.dependencyFiles];
+
+  const buildModeExcludes = {
+    // note: exclude debug in release builds, and release in debug builds
+    [config.releaseBuild ? "debug" : "release"]: true,
+  };
+
+  const fnMap = await fileInfoFromConfig(
+    workspace,
+    external_path_.join(output, "source"),
+    buildConfig,
+    buildModeExcludes
   );
 
+  if (buildConfig.barrelMap) {
+    const barrelFnMaps = await Promise.all(
+      Object.entries(buildConfig.barrelMap)
+        .map(([barrel, resolvedBarrel]) => {
+          dependencyFiles.push(
+            ...resolvedBarrel.jungles,
+            resolvedBarrel.manifest
+          );
+          return fileInfoFromConfig(
+            external_path_.dirname(resolvedBarrel.jungles[0]),
+            external_path_.join(output, "barrels", barrel),
+            resolvedBarrel.qualifier,
+            {
+              ...buildModeExcludes,
+              ...excludesFromAnnotations(
+                barrel,
+                buildConfig.annotations,
+                resolvedBarrel
+              ),
+            }
+          );
+        })
+        .flat()
+    );
+    barrelFnMaps.forEach((barrelFnMap) => Object.assign(fnMap, barrelFnMap));
+  }
+
   const actualOptimizedFiles = (
-    await (0,external_util_cjs_namespaceObject.globa)(external_path_namespaceObject.join(output, "**", "*.mc"), { mark: true })
+    await (0,external_util_cjs_namespaceObject.globa)(external_path_.join(output, "**", "*.mc"), { mark: true })
   )
     .filter((file) => !file.endsWith("/"))
     .sort();
@@ -8932,25 +12091,30 @@ async function generateOneConfig(config) {
   // set of files we're going to generate (in case eg a jungle file change
   // might have altered it)
   if (
-    actualOptimizedFiles.length == files.length &&
+    actualOptimizedFiles.length == Object.values(fnMap).length &&
     Object.values(fnMap)
+      .map((v) => v.output)
       .sort()
       .every((f, i) => f == actualOptimizedFiles[i])
   ) {
     // now if the newest source file is older than
     // the oldest optimized file, we don't need to regenerate
-    const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap));
-    const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap));
-    if (source_time < opt_time && 1651590049006 < opt_time) return;
+    const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(
+      Object.keys(fnMap).concat(dependencyFiles)
+    );
+    const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(
+      Object.values(fnMap).map((v) => v.output)
+    );
+    if (source_time < opt_time && 1652050734499 < opt_time) return;
   }
 
   await promises_namespaceObject.rm(output, { recursive: true, force: true });
   await promises_namespaceObject.mkdir(output, { recursive: true });
-  const optFiles = await optimizeMonkeyC(Object.keys(fnMap), buildConfig);
+  const optFiles = await optimizeMonkeyC(fnMap);
   return await Promise.all(
     optFiles.map(async (file) => {
-      const name = fnMap[file.name];
-      const dir = external_path_namespaceObject.dirname(name);
+      const name = fnMap[file.name].output;
+      const dir = external_path_.dirname(name);
       await promises_namespaceObject.mkdir(dir, { recursive: true });
 
       const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(file.ast);