@markw65/monkeyc-optimizer 1.0.7 → 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) => {
 
@@ -505,6 +1281,986 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 }
 
 
+/***/ }),
+
+/***/ 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)
+}
+
+var isRequest = function (stream) {
+  return stream.setHeader && isFn(stream.abort)
+}
+
+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'))
+  }
+}
+
+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
+
+
 /***/ }),
 
 /***/ 6099:
@@ -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:
@@ -7080,6 +8876,833 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 }).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;
+
+  if (self.refCount > 0) return;
+  if (self.refCount < 0) throw new Error("invalid unref");
+
+  self.close(onCloseDone);
+
+  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);
+
+  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();
+  };
+
+  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();
+  };
+
+  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);
+};
+
+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();
+};
+
+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 result;
+  }
+}
+
+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.
+}
+
+// Node 10 deprecated new Buffer().
+var newBuffer;
+if (typeof Buffer.allocUnsafe === "function") {
+  newBuffer = function(len) {
+    return Buffer.allocUnsafe(len);
+  };
+} else {
+  newBuffer = function(len) {
+    return new Buffer(len);
+  };
+}
+
+function defaultCallback(err) {
+  if (err) throw err;
+}
+
+
+/***/ }),
+
+/***/ 871:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("buffer");
+
+/***/ }),
+
+/***/ 6231:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 1423:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("path");
+
 /***/ }),
 
 /***/ 8311:
@@ -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,18 +9818,23 @@ __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"
+const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
 ;// CONCATENATED MODULE: ./src/build.js
 
 
 
+
 async function build_project(product, options, lineCallback) {
   const {
     workspace,
@@ -7204,7 +9848,7 @@ async function build_project(product, options, lineCallback) {
     typeCheckLevel,
     returnCommand,
   } = options;
-  const sdk = await (0,external_util_cjs_namespaceObject.getSdkPath)();
+  const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
   let extraArgs = [];
   if (compilerOptions) {
     extraArgs.push(...compilerOptions.split(/\s+/));
@@ -7235,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_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],
@@ -7245,28 +9889,21 @@ async function build_project(product, options, lineCallback) {
 
   const handlers = [
     lineCallback || ((line) => console.log(line)),
-    (line) => {
-      if (
-        /^WARNING: .*: Source path '.*' cannot be resolved to a valid path./.test(
-          line
-        )
-      ) {
-        return;
-      }
-      console.error(line);
-    },
+    (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,
       });
 }
 
-;// CONCATENATED MODULE: ./build/jungle.js
-function peg$subclass(u,A){function E(){this.constructor=u}E.prototype=A.prototype,u.prototype=new E}function peg$SyntaxError(u,A,E,C){var F=Error.call(this,u);return Object.setPrototypeOf&&Object.setPrototypeOf(F,peg$SyntaxError.prototype),F.expected=A,F.found=E,F.location=C,F.name="SyntaxError",F}function peg$padEnd(u,A,E){return E=E||" ",u.length>A?u:(A-=u.length,u+(E+=E.repeat(A)).slice(0,A))}function peg$parse(u,A){var E,C,F,t,B={},r=(A=void 0!==A?A:{}).grammarSource,e={Jungle:Su},D=Su,n=/^[\n\r\u2028\u2029]/,o=/^[a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137-\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148-\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C-\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA-\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC-\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF-\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F-\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0-\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB-\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE-\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0560-\u0588\u10D0-\u10FA\u10FD-\u10FF\u13F8-\u13FD\u1C80-\u1C88\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6-\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FC7\u1FD0-\u1FD3\u1FD6-\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6-\u1FF7\u210A\u210E-\u210F\u2113\u212F\u2134\u2139\u213C-\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65-\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73-\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7AF\uA7B5\uA7B7\uA7B9\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A]/,s=/^[\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5-\u06E6\u07F4-\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C-\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D-\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C-\uA69D\uA717-\uA71F\uA770\uA788\uA7F8-\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3-\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E-\uFF9F]/,a=/^[\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05EF-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u09FC\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u1100-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEF\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD-\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,c=/^[\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC]/,l=/^[A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178-\u0179\u017B\u017D\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018B\u018E-\u0191\u0193-\u0194\u0196-\u0198\u019C-\u019D\u019F-\u01A0\u01A2\u01A4\u01A6-\u01A7\u01A9\u01AC\u01AE-\u01AF\u01B1-\u01B3\u01B5\u01B7-\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A-\u023B\u023D-\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9-\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0-\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1C90-\u1CBA\u1CBD-\u1CBF\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E-\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D-\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AE\uA7B0-\uA7B4\uA7B6\uA7B8\uFF21-\uFF3A]/,i=/^[\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0982-\u0983\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0B02-\u0B03\u0B3E\u0B40\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82-\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0D02-\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82-\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2-\u0DF3\u0F3E-\u0F3F\u0F7F\u102B-\u102C\u1031\u1038\u103B-\u103C\u1056-\u1057\u1062-\u1064\u1067-\u106D\u1083-\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7-\u17C8\u1923-\u1926\u1929-\u192B\u1930-\u1931\u1933-\u1938\u1A19-\u1A1A\u1A55\u1A57\u1A61\u1A63-\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B82\u1BA1\u1BA6-\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1C24-\u1C2B\u1C34-\u1C35\u1CE1\u1CF2-\u1CF3\u1CF7\u302E-\u302F\uA823-\uA824\uA827\uA880-\uA881\uA8B4-\uA8C3\uA952-\uA953\uA983\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uAA2F-\uAA30\uAA33-\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE-\uAAEF\uAAF5\uABE3-\uABE4\uABE6-\uABE7\uABE9-\uABEA\uABEC]/,f=/^[\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7-\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962-\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2-\u09E3\u09FE\u0A01-\u0A02\u0A3C\u0A41-\u0A42\u0A47-\u0A48\u0A4B-\u0A4D\u0A51\u0A70-\u0A71\u0A75\u0A81-\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7-\u0AC8\u0ACD\u0AE2-\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B56\u0B62-\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55-\u0C56\u0C62-\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC-\u0CCD\u0CE2-\u0CE3\u0D00-\u0D01\u0D3B-\u0D3C\u0D41-\u0D44\u0D4D\u0D62-\u0D63\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB-\u0EBC\u0EC8-\u0ECD\u0F18-\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86-\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039-\u103A\u103D-\u103E\u1058-\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17B4-\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885-\u1886\u18A9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193B\u1A17-\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80-\u1B81\u1BA2-\u1BA5\u1BA8-\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8-\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099-\u309A\uA66F\uA674-\uA67D\uA69E-\uA69F\uA6F0-\uA6F1\uA802\uA806\uA80B\uA825-\uA826\uA8C4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9E5\uAA29-\uAA2E\uAA31-\uAA32\uAA35-\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7-\uAAB8\uAABE-\uAABF\uAAC1\uAAEC-\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/,h=/^[0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19]/,x=/^[\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF]/,p=/^[_\u203F-\u2040\u2054\uFE33-\uFE34\uFE4D-\uFE4F\uFF3F]/,d=/^[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/,P={type:"any"},g=Pu("=",!1),v=Pu(".",!1),y=Pu(";",!1),m=Pu("$(",!1),$=Pu(")",!1),S=vu("raw string"),b=vu("quoted string"),w=Pu('"',!1),j=Pu("[",!1),O=Pu("]",!1),R=Pu(" ",!1),_=Pu("\t",!1),L=Pu("\\",!1),z=vu("identifier"),M=Pu("_",!1),Z=Pu("$",!1),k=Pu("-",!1),q=Pu("‌",!1),J=Pu("‍",!1),N=Pu("/",!1),Q=Pu("*",!1),U=vu("whitespace"),G=Pu("\v",!1),H=Pu("\f",!1),I=Pu(" ",!1),K=Pu("\ufeff",!1),T=gu(["\n","\r","\u2028","\u2029"],!1,!1),V=vu("end of line"),W=Pu("\n",!1),X=Pu("\r\n",!1),Y=Pu("\r",!1),uu=Pu("\u2028",!1),Au=Pu("\u2029",!1),Eu=vu("comment"),Cu=Pu("#",!1),Fu=gu([["a","z"],"µ",["ß","ö"],["ø","ÿ"],"ā","ă","ą","ć","ĉ","ċ","č","ď","đ","ē","ĕ","ė","ę","ě","ĝ","ğ","ġ","ģ","ĥ","ħ","ĩ","ī","ĭ","į","ı","ij","ĵ",["ķ","ĸ"],"ĺ","ļ","ľ","ŀ","ł","ń","ņ",["ň","ʼn"],"ŋ","ō","ŏ","ő","œ","ŕ","ŗ","ř","ś","ŝ","ş","š","ţ","ť","ŧ","ũ","ū","ŭ","ů","ű","ų","ŵ","ŷ","ź","ż",["ž","ƀ"],"ƃ","ƅ","ƈ",["ƌ","ƍ"],"ƒ","ƕ",["ƙ","ƛ"],"ƞ","ơ","ƣ","ƥ","ƨ",["ƪ","ƫ"],"ƭ","ư","ƴ","ƶ",["ƹ","ƺ"],["ƽ","ƿ"],"dž","lj","nj","ǎ","ǐ","ǒ","ǔ","ǖ","ǘ","ǚ",["ǜ","ǝ"],"ǟ","ǡ","ǣ","ǥ","ǧ","ǩ","ǫ","ǭ",["ǯ","ǰ"],"dz","ǵ","ǹ","ǻ","ǽ","ǿ","ȁ","ȃ","ȅ","ȇ","ȉ","ȋ","ȍ","ȏ","ȑ","ȓ","ȕ","ȗ","ș","ț","ȝ","ȟ","ȡ","ȣ","ȥ","ȧ","ȩ","ȫ","ȭ","ȯ","ȱ",["ȳ","ȹ"],"ȼ",["ȿ","ɀ"],"ɂ","ɇ","ɉ","ɋ","ɍ",["ɏ","ʓ"],["ʕ","ʯ"],"ͱ","ͳ","ͷ",["ͻ","ͽ"],"ΐ",["ά","ώ"],["ϐ","ϑ"],["ϕ","ϗ"],"ϙ","ϛ","ϝ","ϟ","ϡ","ϣ","ϥ","ϧ","ϩ","ϫ","ϭ",["ϯ","ϳ"],"ϵ","ϸ",["ϻ","ϼ"],["а","џ"],"ѡ","ѣ","ѥ","ѧ","ѩ","ѫ","ѭ","ѯ","ѱ","ѳ","ѵ","ѷ","ѹ","ѻ","ѽ","ѿ","ҁ","ҋ","ҍ","ҏ","ґ","ғ","ҕ","җ","ҙ","қ","ҝ","ҟ","ҡ","ң","ҥ","ҧ","ҩ","ҫ","ҭ","ү","ұ","ҳ","ҵ","ҷ","ҹ","һ","ҽ","ҿ","ӂ","ӄ","ӆ","ӈ","ӊ","ӌ",["ӎ","ӏ"],"ӑ","ӓ","ӕ","ӗ","ә","ӛ","ӝ","ӟ","ӡ","ӣ","ӥ","ӧ","ө","ӫ","ӭ","ӯ","ӱ","ӳ","ӵ","ӷ","ӹ","ӻ","ӽ","ӿ","ԁ","ԃ","ԅ","ԇ","ԉ","ԋ","ԍ","ԏ","ԑ","ԓ","ԕ","ԗ","ԙ","ԛ","ԝ","ԟ","ԡ","ԣ","ԥ","ԧ","ԩ","ԫ","ԭ","ԯ",["ՠ","ֈ"],["ა","ჺ"],["ჽ","ჿ"],["ᏸ","ᏽ"],["ᲀ","ᲈ"],["ᴀ","ᴫ"],["ᵫ","ᵷ"],["ᵹ","ᶚ"],"ḁ","ḃ","ḅ","ḇ","ḉ","ḋ","ḍ","ḏ","ḑ","ḓ","ḕ","ḗ","ḙ","ḛ","ḝ","ḟ","ḡ","ḣ","ḥ","ḧ","ḩ","ḫ","ḭ","ḯ","ḱ","ḳ","ḵ","ḷ","ḹ","ḻ","ḽ","ḿ","ṁ","ṃ","ṅ","ṇ","ṉ","ṋ","ṍ","ṏ","ṑ","ṓ","ṕ","ṗ","ṙ","ṛ","ṝ","ṟ","ṡ","ṣ","ṥ","ṧ","ṩ","ṫ","ṭ","ṯ","ṱ","ṳ","ṵ","ṷ","ṹ","ṻ","ṽ","ṿ","ẁ","ẃ","ẅ","ẇ","ẉ","ẋ","ẍ","ẏ","ẑ","ẓ",["ẕ","ẝ"],"ẟ","ạ","ả","ấ","ầ","ẩ","ẫ","ậ","ắ","ằ","ẳ","ẵ","ặ","ẹ","ẻ","ẽ","ế","ề","ể","ễ","ệ","ỉ","ị","ọ","ỏ","ố","ồ","ổ","ỗ","ộ","ớ","ờ","ở","ỡ","ợ","ụ","ủ","ứ","ừ","ử","ữ","ự","ỳ","ỵ","ỷ","ỹ","ỻ","ỽ",["ỿ","ἇ"],["ἐ","ἕ"],["ἠ","ἧ"],["ἰ","ἷ"],["ὀ","ὅ"],["ὐ","ὗ"],["ὠ","ὧ"],["ὰ","ώ"],["ᾀ","ᾇ"],["ᾐ","ᾗ"],["ᾠ","ᾧ"],["ᾰ","ᾴ"],["ᾶ","ᾷ"],"ι",["ῂ","ῄ"],["ῆ","ῇ"],["ῐ","ΐ"],["ῖ","ῗ"],["ῠ","ῧ"],["ῲ","ῴ"],["ῶ","ῷ"],"ℊ",["ℎ","ℏ"],"ℓ","ℯ","ℴ","ℹ",["ℼ","ℽ"],["ⅆ","ⅉ"],"ⅎ","ↄ",["ⰰ","ⱞ"],"ⱡ",["ⱥ","ⱦ"],"ⱨ","ⱪ","ⱬ","ⱱ",["ⱳ","ⱴ"],["ⱶ","ⱻ"],"ⲁ","ⲃ","ⲅ","ⲇ","ⲉ","ⲋ","ⲍ","ⲏ","ⲑ","ⲓ","ⲕ","ⲗ","ⲙ","ⲛ","ⲝ","ⲟ","ⲡ","ⲣ","ⲥ","ⲧ","ⲩ","ⲫ","ⲭ","ⲯ","ⲱ","ⲳ","ⲵ","ⲷ","ⲹ","ⲻ","ⲽ","ⲿ","ⳁ","ⳃ","ⳅ","ⳇ","ⳉ","ⳋ","ⳍ","ⳏ","ⳑ","ⳓ","ⳕ","ⳗ","ⳙ","ⳛ","ⳝ","ⳟ","ⳡ",["ⳣ","ⳤ"],"ⳬ","ⳮ","ⳳ",["ⴀ","ⴥ"],"ⴧ","ⴭ","ꙁ","ꙃ","ꙅ","ꙇ","ꙉ","ꙋ","ꙍ","ꙏ","ꙑ","ꙓ","ꙕ","ꙗ","ꙙ","ꙛ","ꙝ","ꙟ","ꙡ","ꙣ","ꙥ","ꙧ","ꙩ","ꙫ","ꙭ","ꚁ","ꚃ","ꚅ","ꚇ","ꚉ","ꚋ","ꚍ","ꚏ","ꚑ","ꚓ","ꚕ","ꚗ","ꚙ","ꚛ","ꜣ","ꜥ","ꜧ","ꜩ","ꜫ","ꜭ",["ꜯ","ꜱ"],"ꜳ","ꜵ","ꜷ","ꜹ","ꜻ","ꜽ","ꜿ","ꝁ","ꝃ","ꝅ","ꝇ","ꝉ","ꝋ","ꝍ","ꝏ","ꝑ","ꝓ","ꝕ","ꝗ","ꝙ","ꝛ","ꝝ","ꝟ","ꝡ","ꝣ","ꝥ","ꝧ","ꝩ","ꝫ","ꝭ","ꝯ",["ꝱ","ꝸ"],"ꝺ","ꝼ","ꝿ","ꞁ","ꞃ","ꞅ","ꞇ","ꞌ","ꞎ","ꞑ",["ꞓ","ꞕ"],"ꞗ","ꞙ","ꞛ","ꞝ","ꞟ","ꞡ","ꞣ","ꞥ","ꞧ","ꞩ","ꞯ","ꞵ","ꞷ","ꞹ","ꟺ",["ꬰ","ꭚ"],["ꭠ","ꭥ"],["ꭰ","ꮿ"],["ff","st"],["ﬓ","ﬗ"],["ａ","ｚ"]],!1,!1),tu=gu([["ʰ","ˁ"],["ˆ","ˑ"],["ˠ","ˤ"],"ˬ","ˮ","ʹ","ͺ","ՙ","ـ",["ۥ","ۦ"],["ߴ","ߵ"],"ߺ","ࠚ","ࠤ","ࠨ","ॱ","ๆ","ໆ","ჼ","ៗ","ᡃ","ᪧ",["ᱸ","ᱽ"],["ᴬ","ᵪ"],"ᵸ",["ᶛ","ᶿ"],"ⁱ","ⁿ",["ₐ","ₜ"],["ⱼ","ⱽ"],"ⵯ","ⸯ","々",["〱","〵"],"〻",["ゝ","ゞ"],["ー","ヾ"],"ꀕ",["ꓸ","ꓽ"],"ꘌ","ꙿ",["ꚜ","ꚝ"],["ꜗ","ꜟ"],"ꝰ","ꞈ",["ꟸ","ꟹ"],"ꧏ","ꧦ","ꩰ","ꫝ",["ꫳ","ꫴ"],["ꭜ","ꭟ"],"ｰ",["ﾞ","ﾟ"]],!1,!1),Bu=gu(["ª","º","ƻ",["ǀ","ǃ"],"ʔ",["א","ת"],["ׯ","ײ"],["ؠ","ؿ"],["ف","ي"],["ٮ","ٯ"],["ٱ","ۓ"],"ە",["ۮ","ۯ"],["ۺ","ۼ"],"ۿ","ܐ",["ܒ","ܯ"],["ݍ","ޥ"],"ޱ",["ߊ","ߪ"],["ࠀ","ࠕ"],["ࡀ","ࡘ"],["ࡠ","ࡪ"],["ࢠ","ࢴ"],["ࢶ","ࢽ"],["ऄ","ह"],"ऽ","ॐ",["क़","ॡ"],["ॲ","ঀ"],["অ","ঌ"],["এ","ঐ"],["ও","ন"],["প","র"],"ল",["শ","হ"],"ঽ","ৎ",["ড়","ঢ়"],["য়","ৡ"],["ৰ","ৱ"],"ৼ",["ਅ","ਊ"],["ਏ","ਐ"],["ਓ","ਨ"],["ਪ","ਰ"],["ਲ","ਲ਼"],["ਵ","ਸ਼"],["ਸ","ਹ"],["ਖ਼","ੜ"],"ਫ਼",["ੲ","ੴ"],["અ","ઍ"],["એ","ઑ"],["ઓ","ન"],["પ","ર"],["લ","ળ"],["વ","હ"],"ઽ","ૐ",["ૠ","ૡ"],"ૹ",["ଅ","ଌ"],["ଏ","ଐ"],["ଓ","ନ"],["ପ","ର"],["ଲ","ଳ"],["ଵ","ହ"],"ଽ",["ଡ଼","ଢ଼"],["ୟ","ୡ"],"ୱ","ஃ",["அ","ஊ"],["எ","ஐ"],["ஒ","க"],["ங","ச"],"ஜ",["ஞ","ட"],["ண","த"],["ந","ப"],["ம","ஹ"],"ௐ",["అ","ఌ"],["ఎ","ఐ"],["ఒ","న"],["ప","హ"],"ఽ",["ౘ","ౚ"],["ౠ","ౡ"],"ಀ",["ಅ","ಌ"],["ಎ","ಐ"],["ಒ","ನ"],["ಪ","ಳ"],["ವ","ಹ"],"ಽ","ೞ",["ೠ","ೡ"],["ೱ","ೲ"],["അ","ഌ"],["എ","ഐ"],["ഒ","ഺ"],"ഽ","ൎ",["ൔ","ൖ"],["ൟ","ൡ"],["ൺ","ൿ"],["අ","ඖ"],["ක","න"],["ඳ","ර"],"ල",["ව","ෆ"],["ก","ะ"],["า","ำ"],["เ","ๅ"],["ກ","ຂ"],"ຄ",["ງ","ຈ"],"ຊ","ຍ",["ດ","ທ"],["ນ","ຟ"],["ມ","ຣ"],"ລ","ວ",["ສ","ຫ"],["ອ","ະ"],["າ","ຳ"],"ຽ",["ເ","ໄ"],["ໜ","ໟ"],"ༀ",["ཀ","ཇ"],["ཉ","ཬ"],["ྈ","ྌ"],["က","ဪ"],"ဿ",["ၐ","ၕ"],["ၚ","ၝ"],"ၡ",["ၥ","ၦ"],["ၮ","ၰ"],["ၵ","ႁ"],"ႎ",["ᄀ","ቈ"],["ቊ","ቍ"],["ቐ","ቖ"],"ቘ",["ቚ","ቝ"],["በ","ኈ"],["ኊ","ኍ"],["ነ","ኰ"],["ኲ","ኵ"],["ኸ","ኾ"],"ዀ",["ዂ","ዅ"],["ወ","ዖ"],["ዘ","ጐ"],["ጒ","ጕ"],["ጘ","ፚ"],["ᎀ","ᎏ"],["ᐁ","ᙬ"],["ᙯ","ᙿ"],["ᚁ","ᚚ"],["ᚠ","ᛪ"],["ᛱ","ᛸ"],["ᜀ","ᜌ"],["ᜎ","ᜑ"],["ᜠ","ᜱ"],["ᝀ","ᝑ"],["ᝠ","ᝬ"],["ᝮ","ᝰ"],["ក","ឳ"],"ៜ",["ᠠ","ᡂ"],["ᡄ","ᡸ"],["ᢀ","ᢄ"],["ᢇ","ᢨ"],"ᢪ",["ᢰ","ᣵ"],["ᤀ","ᤞ"],["ᥐ","ᥭ"],["ᥰ","ᥴ"],["ᦀ","ᦫ"],["ᦰ","ᧉ"],["ᨀ","ᨖ"],["ᨠ","ᩔ"],["ᬅ","ᬳ"],["ᭅ","ᭋ"],["ᮃ","ᮠ"],["ᮮ","ᮯ"],["ᮺ","ᯥ"],["ᰀ","ᰣ"],["ᱍ","ᱏ"],["ᱚ","ᱷ"],["ᳩ","ᳬ"],["ᳮ","ᳱ"],["ᳵ","ᳶ"],["ℵ","ℸ"],["ⴰ","ⵧ"],["ⶀ","ⶖ"],["ⶠ","ⶦ"],["ⶨ","ⶮ"],["ⶰ","ⶶ"],["ⶸ","ⶾ"],["ⷀ","ⷆ"],["ⷈ","ⷎ"],["ⷐ","ⷖ"],["ⷘ","ⷞ"],"〆","〼",["ぁ","ゖ"],"ゟ",["ァ","ヺ"],"ヿ",["ㄅ","ㄯ"],["ㄱ","ㆎ"],["ㆠ","ㆺ"],["ㇰ","ㇿ"],["㐀","䶵"],["一","鿯"],["ꀀ","ꀔ"],["ꀖ","ꒌ"],["ꓐ","ꓷ"],["ꔀ","ꘋ"],["ꘐ","ꘟ"],["ꘪ","ꘫ"],"ꙮ",["ꚠ","ꛥ"],"ꞏ","ꟷ",["ꟻ","ꠁ"],["ꠃ","ꠅ"],["ꠇ","ꠊ"],["ꠌ","ꠢ"],["ꡀ","ꡳ"],["ꢂ","ꢳ"],["ꣲ","ꣷ"],"ꣻ",["ꣽ","ꣾ"],["ꤊ","ꤥ"],["ꤰ","ꥆ"],["ꥠ","ꥼ"],["ꦄ","ꦲ"],["ꧠ","ꧤ"],["ꧧ","ꧯ"],["ꧺ","ꧾ"],["ꨀ","ꨨ"],["ꩀ","ꩂ"],["ꩄ","ꩋ"],["ꩠ","ꩯ"],["ꩱ","ꩶ"],"ꩺ",["ꩾ","ꪯ"],"ꪱ",["ꪵ","ꪶ"],["ꪹ","ꪽ"],"ꫀ","ꫂ",["ꫛ","ꫜ"],["ꫠ","ꫪ"],"ꫲ",["ꬁ","ꬆ"],["ꬉ","ꬎ"],["ꬑ","ꬖ"],["ꬠ","ꬦ"],["ꬨ","ꬮ"],["ꯀ","ꯢ"],["가","힣"],["ힰ","ퟆ"],["ퟋ","ퟻ"],["豈","舘"],["並","龎"],"יִ",["ײַ","ﬨ"],["שׁ","זּ"],["טּ","לּ"],"מּ",["נּ","סּ"],["ףּ","פּ"],["צּ","ﮱ"],["ﯓ","ﴽ"],["ﵐ","ﶏ"],["ﶒ","ﷇ"],["ﷰ","ﷻ"],["ﹰ","ﹴ"],["ﹶ","ﻼ"],["ｦ","ｯ"],["ｱ","ﾝ"],["ﾠ","ﾾ"],["ￂ","ￇ"],["ￊ","ￏ"],["ￒ","ￗ"],["ￚ","ￜ"]],!1,!1),ru=gu(["Dž","Lj","Nj","Dz",["ᾈ","ᾏ"],["ᾘ","ᾟ"],["ᾨ","ᾯ"],"ᾼ","ῌ","ῼ"],!1,!1),eu=gu([["A","Z"],["À","Ö"],["Ø","Þ"],"Ā","Ă","Ą","Ć","Ĉ","Ċ","Č","Ď","Đ","Ē","Ĕ","Ė","Ę","Ě","Ĝ","Ğ","Ġ","Ģ","Ĥ","Ħ","Ĩ","Ī","Ĭ","Į","İ","IJ","Ĵ","Ķ","Ĺ","Ļ","Ľ","Ŀ","Ł","Ń","Ņ","Ň","Ŋ","Ō","Ŏ","Ő","Œ","Ŕ","Ŗ","Ř","Ś","Ŝ","Ş","Š","Ţ","Ť","Ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","Ŵ","Ŷ",["Ÿ","Ź"],"Ż","Ž",["Ɓ","Ƃ"],"Ƅ",["Ɔ","Ƈ"],["Ɖ","Ƌ"],["Ǝ","Ƒ"],["Ɠ","Ɣ"],["Ɩ","Ƙ"],["Ɯ","Ɲ"],["Ɵ","Ơ"],"Ƣ","Ƥ",["Ʀ","Ƨ"],"Ʃ","Ƭ",["Ʈ","Ư"],["Ʊ","Ƴ"],"Ƶ",["Ʒ","Ƹ"],"Ƽ","DŽ","LJ","NJ","Ǎ","Ǐ","Ǒ","Ǔ","Ǖ","Ǘ","Ǚ","Ǜ","Ǟ","Ǡ","Ǣ","Ǥ","Ǧ","Ǩ","Ǫ","Ǭ","Ǯ","DZ","Ǵ",["Ƕ","Ǹ"],"Ǻ","Ǽ","Ǿ","Ȁ","Ȃ","Ȅ","Ȇ","Ȉ","Ȋ","Ȍ","Ȏ","Ȑ","Ȓ","Ȕ","Ȗ","Ș","Ț","Ȝ","Ȟ","Ƞ","Ȣ","Ȥ","Ȧ","Ȩ","Ȫ","Ȭ","Ȯ","Ȱ","Ȳ",["Ⱥ","Ȼ"],["Ƚ","Ⱦ"],"Ɂ",["Ƀ","Ɇ"],"Ɉ","Ɋ","Ɍ","Ɏ","Ͱ","Ͳ","Ͷ","Ϳ","Ά",["Έ","Ί"],"Ό",["Ύ","Ώ"],["Α","Ρ"],["Σ","Ϋ"],"Ϗ",["ϒ","ϔ"],"Ϙ","Ϛ","Ϝ","Ϟ","Ϡ","Ϣ","Ϥ","Ϧ","Ϩ","Ϫ","Ϭ","Ϯ","ϴ","Ϸ",["Ϲ","Ϻ"],["Ͻ","Я"],"Ѡ","Ѣ","Ѥ","Ѧ","Ѩ","Ѫ","Ѭ","Ѯ","Ѱ","Ѳ","Ѵ","Ѷ","Ѹ","Ѻ","Ѽ","Ѿ","Ҁ","Ҋ","Ҍ","Ҏ","Ґ","Ғ","Ҕ","Җ","Ҙ","Қ","Ҝ","Ҟ","Ҡ","Ң","Ҥ","Ҧ","Ҩ","Ҫ","Ҭ","Ү","Ұ","Ҳ","Ҵ","Ҷ","Ҹ","Һ","Ҽ","Ҿ",["Ӏ","Ӂ"],"Ӄ","Ӆ","Ӈ","Ӊ","Ӌ","Ӎ","Ӑ","Ӓ","Ӕ","Ӗ","Ә","Ӛ","Ӝ","Ӟ","Ӡ","Ӣ","Ӥ","Ӧ","Ө","Ӫ","Ӭ","Ӯ","Ӱ","Ӳ","Ӵ","Ӷ","Ӹ","Ӻ","Ӽ","Ӿ","Ԁ","Ԃ","Ԅ","Ԇ","Ԉ","Ԋ","Ԍ","Ԏ","Ԑ","Ԓ","Ԕ","Ԗ","Ԙ","Ԛ","Ԝ","Ԟ","Ԡ","Ԣ","Ԥ","Ԧ","Ԩ","Ԫ","Ԭ","Ԯ",["Ա","Ֆ"],["Ⴀ","Ⴥ"],"Ⴧ","Ⴭ",["Ꭰ","Ᏽ"],["Ა","Ჺ"],["Ჽ","Ჿ"],"Ḁ","Ḃ","Ḅ","Ḇ","Ḉ","Ḋ","Ḍ","Ḏ","Ḑ","Ḓ","Ḕ","Ḗ","Ḙ","Ḛ","Ḝ","Ḟ","Ḡ","Ḣ","Ḥ","Ḧ","Ḩ","Ḫ","Ḭ","Ḯ","Ḱ","Ḳ","Ḵ","Ḷ","Ḹ","Ḻ","Ḽ","Ḿ","Ṁ","Ṃ","Ṅ","Ṇ","Ṉ","Ṋ","Ṍ","Ṏ","Ṑ","Ṓ","Ṕ","Ṗ","Ṙ","Ṛ","Ṝ","Ṟ","Ṡ","Ṣ","Ṥ","Ṧ","Ṩ","Ṫ","Ṭ","Ṯ","Ṱ","Ṳ","Ṵ","Ṷ","Ṹ","Ṻ","Ṽ","Ṿ","Ẁ","Ẃ","Ẅ","Ẇ","Ẉ","Ẋ","Ẍ","Ẏ","Ẑ","Ẓ","Ẕ","ẞ","Ạ","Ả","Ấ","Ầ","Ẩ","Ẫ","Ậ","Ắ","Ằ","Ẳ","Ẵ","Ặ","Ẹ","Ẻ","Ẽ","Ế","Ề","Ể","Ễ","Ệ","Ỉ","Ị","Ọ","Ỏ","Ố","Ồ","Ổ","Ỗ","Ộ","Ớ","Ờ","Ở","Ỡ","Ợ","Ụ","Ủ","Ứ","Ừ","Ử","Ữ","Ự","Ỳ","Ỵ","Ỷ","Ỹ","Ỻ","Ỽ","Ỿ",["Ἀ","Ἇ"],["Ἐ","Ἕ"],["Ἠ","Ἧ"],["Ἰ","Ἷ"],["Ὀ","Ὅ"],"Ὑ","Ὓ","Ὕ","Ὗ",["Ὠ","Ὧ"],["Ᾰ","Ά"],["Ὲ","Ή"],["Ῐ","Ί"],["Ῠ","Ῥ"],["Ὸ","Ώ"],"ℂ","ℇ",["ℋ","ℍ"],["ℐ","ℒ"],"ℕ",["ℙ","ℝ"],"ℤ","Ω","ℨ",["K","ℭ"],["ℰ","ℳ"],["ℾ","ℿ"],"ⅅ","Ↄ",["Ⰰ","Ⱞ"],"Ⱡ",["Ɫ","Ɽ"],"Ⱨ","Ⱪ","Ⱬ",["Ɑ","Ɒ"],"Ⱳ","Ⱶ",["Ȿ","Ⲁ"],"Ⲃ","Ⲅ","Ⲇ","Ⲉ","Ⲋ","Ⲍ","Ⲏ","Ⲑ","Ⲓ","Ⲕ","Ⲗ","Ⲙ","Ⲛ","Ⲝ","Ⲟ","Ⲡ","Ⲣ","Ⲥ","Ⲧ","Ⲩ","Ⲫ","Ⲭ","Ⲯ","Ⲱ","Ⲳ","Ⲵ","Ⲷ","Ⲹ","Ⲻ","Ⲽ","Ⲿ","Ⳁ","Ⳃ","Ⳅ","Ⳇ","Ⳉ","Ⳋ","Ⳍ","Ⳏ","Ⳑ","Ⳓ","Ⳕ","Ⳗ","Ⳙ","Ⳛ","Ⳝ","Ⳟ","Ⳡ","Ⳣ","Ⳬ","Ⳮ","Ⳳ","Ꙁ","Ꙃ","Ꙅ","Ꙇ","Ꙉ","Ꙋ","Ꙍ","Ꙏ","Ꙑ","Ꙓ","Ꙕ","Ꙗ","Ꙙ","Ꙛ","Ꙝ","Ꙟ","Ꙡ","Ꙣ","Ꙥ","Ꙧ","Ꙩ","Ꙫ","Ꙭ","Ꚁ","Ꚃ","Ꚅ","Ꚇ","Ꚉ","Ꚋ","Ꚍ","Ꚏ","Ꚑ","Ꚓ","Ꚕ","Ꚗ","Ꚙ","Ꚛ","Ꜣ","Ꜥ","Ꜧ","Ꜩ","Ꜫ","Ꜭ","Ꜯ","Ꜳ","Ꜵ","Ꜷ","Ꜹ","Ꜻ","Ꜽ","Ꜿ","Ꝁ","Ꝃ","Ꝅ","Ꝇ","Ꝉ","Ꝋ","Ꝍ","Ꝏ","Ꝑ","Ꝓ","Ꝕ","Ꝗ","Ꝙ","Ꝛ","Ꝝ","Ꝟ","Ꝡ","Ꝣ","Ꝥ","Ꝧ","Ꝩ","Ꝫ","Ꝭ","Ꝯ","Ꝺ","Ꝼ",["Ᵹ","Ꝿ"],"Ꞁ","Ꞃ","Ꞅ","Ꞇ","Ꞌ","Ɥ","Ꞑ","Ꞓ","Ꞗ","Ꞙ","Ꞛ","Ꞝ","Ꞟ","Ꞡ","Ꞣ","Ꞥ","Ꞧ","Ꞩ",["Ɦ","Ɪ"],["Ʞ","Ꞵ"],"Ꞷ","Ꞹ",["Ａ","Ｚ"]],!1,!1),Du=gu(["ः","ऻ",["ा","ी"],["ॉ","ौ"],["ॎ","ॏ"],["ং","ঃ"],["া","ী"],["ে","ৈ"],["ো","ৌ"],"ৗ","ਃ",["ਾ","ੀ"],"ઃ",["ા","ી"],"ૉ",["ો","ૌ"],["ଂ","ଃ"],"ା","ୀ",["େ","ୈ"],["ୋ","ୌ"],"ୗ",["ா","ி"],["ு","ூ"],["ெ","ை"],["ொ","ௌ"],"ௗ",["ఁ","ః"],["ు","ౄ"],["ಂ","ಃ"],"ಾ",["ೀ","ೄ"],["ೇ","ೈ"],["ೊ","ೋ"],["ೕ","ೖ"],["ം","ഃ"],["ാ","ീ"],["െ","ൈ"],["ൊ","ൌ"],"ൗ",["ං","ඃ"],["ා","ෑ"],["ෘ","ෟ"],["ෲ","ෳ"],["༾","༿"],"ཿ",["ါ","ာ"],"ေ","း",["ျ","ြ"],["ၖ","ၗ"],["ၢ","ၤ"],["ၧ","ၭ"],["ႃ","ႄ"],["ႇ","ႌ"],"ႏ",["ႚ","ႜ"],"ា",["ើ","ៅ"],["ះ","ៈ"],["ᤣ","ᤦ"],["ᤩ","ᤫ"],["ᤰ","ᤱ"],["ᤳ","ᤸ"],["ᨙ","ᨚ"],"ᩕ","ᩗ","ᩡ",["ᩣ","ᩤ"],["ᩭ","ᩲ"],"ᬄ","ᬵ","ᬻ",["ᬽ","ᭁ"],["ᭃ","᭄"],"ᮂ","ᮡ",["ᮦ","ᮧ"],"᮪","ᯧ",["ᯪ","ᯬ"],"ᯮ",["᯲","᯳"],["ᰤ","ᰫ"],["ᰴ","ᰵ"],"᳡",["ᳲ","ᳳ"],"᳷",["〮","〯"],["ꠣ","ꠤ"],"ꠧ",["ꢀ","ꢁ"],["ꢴ","ꣃ"],["ꥒ","꥓"],"ꦃ",["ꦴ","ꦵ"],["ꦺ","ꦻ"],["ꦽ","꧀"],["ꨯ","ꨰ"],["ꨳ","ꨴ"],"ꩍ","ꩻ","ꩽ","ꫫ",["ꫮ","ꫯ"],"ꫵ",["ꯣ","ꯤ"],["ꯦ","ꯧ"],["ꯩ","ꯪ"],"꯬"],!1,!1),nu=gu([["̀","ͯ"],["҃","҇"],["֑","ֽ"],"ֿ",["ׁ","ׂ"],["ׄ","ׅ"],"ׇ",["ؐ","ؚ"],["ً","ٟ"],"ٰ",["ۖ","ۜ"],["۟","ۤ"],["ۧ","ۨ"],["۪","ۭ"],"ܑ",["ܰ","݊"],["ަ","ް"],["߫","߳"],"߽",["ࠖ","࠙"],["ࠛ","ࠣ"],["ࠥ","ࠧ"],["ࠩ","࠭"],["࡙","࡛"],["࣓","࣡"],["ࣣ","ं"],"ऺ","़",["ु","ै"],"्",["॑","ॗ"],["ॢ","ॣ"],"ঁ","়",["ু","ৄ"],"্",["ৢ","ৣ"],"৾",["ਁ","ਂ"],"਼",["ੁ","ੂ"],["ੇ","ੈ"],["ੋ","੍"],"ੑ",["ੰ","ੱ"],"ੵ",["ઁ","ં"],"઼",["ુ","ૅ"],["ે","ૈ"],"્",["ૢ","ૣ"],["ૺ","૿"],"ଁ","଼","ି",["ୁ","ୄ"],"୍","ୖ",["ୢ","ୣ"],"ஂ","ீ","்","ఀ","ఄ",["ా","ీ"],["ె","ై"],["ొ","్"],["ౕ","ౖ"],["ౢ","ౣ"],"ಁ","಼","ಿ","ೆ",["ೌ","್"],["ೢ","ೣ"],["ഀ","ഁ"],["഻","഼"],["ു","ൄ"],"്",["ൢ","ൣ"],"්",["ි","ු"],"ූ","ั",["ิ","ฺ"],["็","๎"],"ັ",["ິ","ູ"],["ົ","ຼ"],["່","ໍ"],["༘","༙"],"༵","༷","༹",["ཱ","ཾ"],["ྀ","྄"],["྆","྇"],["ྍ","ྗ"],["ྙ","ྼ"],"࿆",["ိ","ူ"],["ဲ","့"],["္","်"],["ွ","ှ"],["ၘ","ၙ"],["ၞ","ၠ"],["ၱ","ၴ"],"ႂ",["ႅ","ႆ"],"ႍ","ႝ",["፝","፟"],["ᜒ","᜔"],["ᜲ","᜴"],["ᝒ","ᝓ"],["ᝲ","ᝳ"],["឴","឵"],["ិ","ួ"],"ំ",["៉","៓"],"៝",["᠋","᠍"],["ᢅ","ᢆ"],"ᢩ",["ᤠ","ᤢ"],["ᤧ","ᤨ"],"ᤲ",["᤹","᤻"],["ᨗ","ᨘ"],"ᨛ","ᩖ",["ᩘ","ᩞ"],"᩠","ᩢ",["ᩥ","ᩬ"],["ᩳ","᩼"],"᩿",["᪰","᪽"],["ᬀ","ᬃ"],"᬴",["ᬶ","ᬺ"],"ᬼ","ᭂ",["᭫","᭳"],["ᮀ","ᮁ"],["ᮢ","ᮥ"],["ᮨ","ᮩ"],["᮫","ᮭ"],"᯦",["ᯨ","ᯩ"],"ᯭ",["ᯯ","ᯱ"],["ᰬ","ᰳ"],["ᰶ","᰷"],["᳐","᳒"],["᳔","᳠"],["᳢","᳨"],"᳭","᳴",["᳸","᳹"],["᷀","᷹"],["᷻","᷿"],["⃐","⃜"],"⃡",["⃥","⃰"],["⳯","⳱"],"⵿",["ⷠ","ⷿ"],["〪","〭"],["゙","゚"],"꙯",["ꙴ","꙽"],["ꚞ","ꚟ"],["꛰","꛱"],"ꠂ","꠆","ꠋ",["ꠥ","ꠦ"],["꣄","ꣅ"],["꣠","꣱"],"ꣿ",["ꤦ","꤭"],["ꥇ","ꥑ"],["ꦀ","ꦂ"],"꦳",["ꦶ","ꦹ"],"ꦼ","ꧥ",["ꨩ","ꨮ"],["ꨱ","ꨲ"],["ꨵ","ꨶ"],"ꩃ","ꩌ","ꩼ","ꪰ",["ꪲ","ꪴ"],["ꪷ","ꪸ"],["ꪾ","꪿"],"꫁",["ꫬ","ꫭ"],"꫶","ꯥ","ꯨ","꯭","ﬞ",["︀","️"],["︠","︯"]],!1,!1),ou=gu([["0","9"],["٠","٩"],["۰","۹"],["߀","߉"],["०","९"],["০","৯"],["੦","੯"],["૦","૯"],["୦","୯"],["௦","௯"],["౦","౯"],["೦","೯"],["൦","൯"],["෦","෯"],["๐","๙"],["໐","໙"],["༠","༩"],["၀","၉"],["႐","႙"],["០","៩"],["᠐","᠙"],["᥆","᥏"],["᧐","᧙"],["᪀","᪉"],["᪐","᪙"],["᭐","᭙"],["᮰","᮹"],["᱀","᱉"],["᱐","᱙"],["꘠","꘩"],["꣐","꣙"],["꤀","꤉"],["꧐","꧙"],["꧰","꧹"],["꩐","꩙"],["꯰","꯹"],["０","９"]],!1,!1),su=gu([["ᛮ","ᛰ"],["Ⅰ","ↂ"],["ↅ","ↈ"],"〇",["〡","〩"],["〸","〺"],["ꛦ","ꛯ"]],!1,!1),au=gu(["_",["‿","⁀"],"⁔",["︳","︴"],["﹍","﹏"],"＿"],!1,!1),cu=gu([" "," "," ",[" "," "]," "," ","　"],!1,!1),lu=0,iu=0,fu=[{line:1,column:1}],hu=0,xu=[],pu=0,du={};if("startRule"in A){if(!(A.startRule in e))throw new Error("Can't start parsing from rule \""+A.startRule+'".');D=e[A.startRule]}function Pu(u,A){return{type:"literal",text:u,ignoreCase:A}}function gu(u,A,E){return{type:"class",parts:u,inverted:A,ignoreCase:E}}function vu(u){return{type:"other",description:u}}function yu(A){var E,C=fu[A];if(C)return C;for(E=A-1;!fu[E];)E--;for(C={line:(C=fu[E]).line,column:C.column};E<A;)10===u.charCodeAt(E)?(C.line++,C.column=1):C.column++,E++;return fu[A]=C,C}function mu(u,A){var E=yu(u),C=yu(A);return{source:r,start:{offset:u,line:E.line,column:E.column},end:{offset:A,line:C.line,column:C.column}}}function $u(u){lu<hu||(lu>hu&&(hu=lu,xu=[]),xu.push(u))}function Su(){var A,E,C,F,t,r=32*lu+0,e=du[r];if(e)return lu=e.nextPos,e.result;for(A=lu,E=[],C=lu,F=Ru(),(t=bu())!==B?C=t:(lu=C,C=B);C!==B;)E.push(C),C=lu,F=Ru(),(t=bu())!==B?C=t:(lu=C,C=B);return C=Ru(),F=lu,pu++,u.length>lu?(t=u.charAt(lu),lu++):(t=B,0===pu&&$u(P)),pu--,t===B?F=void 0:(lu=F,F=B),F!==B?A=E:(lu=A,A=B),du[r]={nextPos:lu,result:A},A}function bu(){var A,E,C,F,t,r=32*lu+1,e=du[r];return e?(lu=e.nextPos,e.result):(A=lu,(E=wu())!==B?(Ru(),61===u.charCodeAt(lu)?(C="=",lu++):(C=B,0===pu&&$u(g)),C!==B?(Ru(),(F=ju())!==B?(Ru(),iu=A,t=F,A=Uu({names:E.names,values:t})):(lu=A,A=B)):(lu=A,A=B)):(lu=A,A=B),du[r]={nextPos:lu,result:A},A)}function wu(){var A,E,C,F,t,r,e,D=32*lu+2,n=du[D];if(n)return lu=n.nextPos,n.result;if(A=lu,(E=Lu())!==B){for(C=[],F=lu,_u(),46===u.charCodeAt(lu)?(t=".",lu++):(t=B,0===pu&&$u(v)),t!==B?(_u(),(r=Lu())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);F!==B;)C.push(F),F=lu,_u(),46===u.charCodeAt(lu)?(t=".",lu++):(t=B,0===pu&&$u(v)),t!==B?(_u(),(r=Lu())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);iu=A,e=C,A=Uu({type:"QualifiedName",names:[E,...e]})}else lu=A,A=B;return du[D]={nextPos:lu,result:A},A}function ju(){var A,E,C,F,t,r,e,D=32*lu+3,n=du[D];if(n)return lu=n.nextPos,n.result;if(A=lu,(E=Ou())!==B){for(C=[],F=lu,_u(),59===u.charCodeAt(lu)?(t=";",lu++):(t=B,0===pu&&$u(y)),t!==B?(_u(),(r=Ou())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);F!==B;)C.push(F),F=lu,_u(),59===u.charCodeAt(lu)?(t=";",lu++):(t=B,0===pu&&$u(y)),t!==B?(_u(),(r=Ou())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);iu=A,e=C,A=[E,...e]}else lu=A,A=B;return du[D]={nextPos:lu,result:A},A}function Ou(){var A,E,C,F,t=32*lu+4,r=du[t];return r?(lu=r.nextPos,r.result):(A=lu,"$("===u.substr(lu,2)?(E="$(",lu+=2):(E=B,0===pu&&$u(m)),E!==B&&(C=wu())!==B?(41===u.charCodeAt(lu)?(F=")",lu++):(F=B,0===pu&&$u($)),F!==B?A=C:(lu=A,A=B)):(lu=A,A=B),A===B&&(A=function(){var u,A,E,C,F,t=32*lu+5,r=du[t];if(r)return lu=r.nextPos,r.result;if(pu++,u=lu,(A=Zu())!==B){for(E=[],C=lu,_u(),(F=Zu())!==B?C=F:(lu=C,C=B);C!==B;)E.push(C),C=lu,_u(),(F=Zu())!==B?C=F:(lu=C,C=B);iu=u,u=Uu({type:"Literal",value:A+E.join("")})}else lu=u,u=B;return pu--,u===B&&(A=B,0===pu&&$u(S)),du[t]={nextPos:lu,result:u},u}(),A===B&&(A=function(){var A,E,C,F,t,r,e,D,n,o,s=32*lu+6,a=du[s];if(a)return lu=a.nextPos,a.result;if(pu++,A=lu,34===u.charCodeAt(lu)?(E='"',lu++):(E=B,0===pu&&$u(w)),E!==B){if(C=lu,F=lu,t=[],(r=Zu())!==B)for(;r!==B;)t.push(r),r=Zu();else t=B;if(t!==B){if(r=[],e=lu,D=[],(n=qu())!==B)for(;n!==B;)D.push(n),n=qu();else D=B;if(D!==B){if(n=[],(o=Zu())!==B)for(;o!==B;)n.push(o),o=Zu();else n=B;n!==B?e=D=[D,n]:(lu=e,e=B)}else lu=e,e=B;for(;e!==B;){if(r.push(e),e=lu,D=[],(n=qu())!==B)for(;n!==B;)D.push(n),n=qu();else D=B;if(D!==B){if(n=[],(o=Zu())!==B)for(;o!==B;)n.push(o),o=Zu();else n=B;n!==B?e=D=[D,n]:(lu=e,e=B)}else lu=e,e=B}for(e=[],D=qu();D!==B;)e.push(D),D=qu();F=t=[t,r,e]}else lu=F,F=B;(C=F!==B?u.substring(C,lu):F)!==B?(34===u.charCodeAt(lu)?(F='"',lu++):(F=B,0===pu&&$u(w)),F!==B?(iu=A,A=Uu({type:"Literal",value:C})):(lu=A,A=B)):(lu=A,A=B)}else lu=A,A=B;return pu--,A===B&&(E=B,0===pu&&$u(b)),du[s]={nextPos:lu,result:A},A}(),A===B&&(A=function(){var A,E,C,F,t=32*lu+7,r=du[t];return r?(lu=r.nextPos,r.result):(A=lu,91===u.charCodeAt(lu)?(E="[",lu++):(E=B,0===pu&&$u(j)),E!==B&&(C=ju())!==B?(93===u.charCodeAt(lu)?(F="]",lu++):(F=B,0===pu&&$u(O)),F!==B?(iu=A,A=Uu({type:"SubList",values:C})):(lu=A,A=B)):(lu=A,A=B),du[t]={nextPos:lu,result:A},A)}()))),du[t]={nextPos:lu,result:A},A)}function Ru(){var u,A,E=32*lu+8,C=du[E];if(C)return lu=C.nextPos,C.result;for(u=[],(A=qu())===B&&(A=Nu())===B&&(A=Qu());A!==B;)u.push(A),(A=qu())===B&&(A=Nu())===B&&(A=Qu());return du[E]={nextPos:lu,result:u},u}function _u(){var A,E,C,F,t=32*lu+9,r=du[t];if(r)return lu=r.nextPos,r.result;for(A=[],32===u.charCodeAt(lu)?(E=" ",lu++):(E=B,0===pu&&$u(R)),E===B&&(9===u.charCodeAt(lu)?(E="\t",lu++):(E=B,0===pu&&$u(_)),E===B&&(E=lu,92===u.charCodeAt(lu)?(C="\\",lu++):(C=B,0===pu&&$u(L)),C!==B&&(F=Nu())!==B?E=C=[C,F]:(lu=E,E=B),E===B&&(E=Qu())));E!==B;)A.push(E),32===u.charCodeAt(lu)?(E=" ",lu++):(E=B,0===pu&&$u(R)),E===B&&(9===u.charCodeAt(lu)?(E="\t",lu++):(E=B,0===pu&&$u(_)),E===B&&(E=lu,92===u.charCodeAt(lu)?(C="\\",lu++):(C=B,0===pu&&$u(L)),C!==B&&(F=Nu())!==B?E=C=[C,F]:(lu=E,E=B),E===B&&(E=Qu())));return du[t]={nextPos:lu,result:A},A}function Lu(){var u,A,E,C,F=32*lu+10,t=du[F];if(t)return lu=t.nextPos,t.result;if(pu++,u=lu,(A=zu())!==B){for(E=[],C=Mu();C!==B;)E.push(C),C=Mu();iu=u,u=A+E.join("")}else lu=u,u=B;return pu--,u===B&&(A=B,0===pu&&$u(z)),du[F]={nextPos:lu,result:u},u}function zu(){var A,E=32*lu+11,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+14,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+25,C=du[E];return C?(lu=C.nextPos,C.result):(l.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(eu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+21,C=du[E];return C?(lu=C.nextPos,C.result):(o.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Fu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+24,C=du[E];return C?(lu=C.nextPos,C.result):(c.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(ru)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+22,C=du[E];return C?(lu=C.nextPos,C.result):(s.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(tu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+23,C=du[E];return C?(lu=C.nextPos,C.result):(a.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Bu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+29,C=du[E];return C?(lu=C.nextPos,C.result):(x.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(su)),du[E]={nextPos:lu,result:A},A)}()))))),du[E]={nextPos:lu,result:A},A)}(),A===B&&(95===u.charCodeAt(lu)?(A="_",lu++):(A=B,0===pu&&$u(M))),du[E]={nextPos:lu,result:A},A)}function Mu(){var A,E=32*lu+12,C=du[E];return C?(lu=C.nextPos,C.result):((A=zu())===B&&(A=function(){var A,E=32*lu+15,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+27,C=du[E];return C?(lu=C.nextPos,C.result):(f.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(nu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+26,C=du[E];return C?(lu=C.nextPos,C.result):(i.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Du)),du[E]={nextPos:lu,result:A},A)}()),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+28,C=du[E];return C?(lu=C.nextPos,C.result):(h.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(ou)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+30,C=du[E];return C?(lu=C.nextPos,C.result):(p.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(au)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(36===u.charCodeAt(lu)?(A="$",lu++):(A=B,0===pu&&$u(Z)),A===B&&(45===u.charCodeAt(lu)?(A="-",lu++):(A=B,0===pu&&$u(k)),A===B&&(8204===u.charCodeAt(lu)?(A="‌",lu++):(A=B,0===pu&&$u(q)),A===B&&(8205===u.charCodeAt(lu)?(A="‍",lu++):(A=B,0===pu&&$u(J))))))))),du[E]={nextPos:lu,result:A},A)}function Zu(){var A,E,C=32*lu+13,F=du[C];return F?(lu=F.nextPos,F.result):((A=Mu())===B&&(46===u.charCodeAt(lu)?(A=".",lu++):(A=B,0===pu&&$u(v)),A===B&&(47===u.charCodeAt(lu)?(A="/",lu++):(A=B,0===pu&&$u(N)),A===B&&(42===u.charCodeAt(lu)?(A="*",lu++):(A=B,0===pu&&$u(Q)),A===B&&(A=lu,92===u.charCodeAt(lu)?(E="\\",lu++):(E=B,0===pu&&$u(L)),E!==B&&(iu=A,E="/"),A=E)))),du[C]={nextPos:lu,result:A},A)}function ku(){var A,E=32*lu+16,C=du[E];return C?(lu=C.nextPos,C.result):(u.length>lu?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(P)),du[E]={nextPos:lu,result:A},A)}function qu(){var A,E=32*lu+17,C=du[E];return C?(lu=C.nextPos,C.result):(pu++,9===u.charCodeAt(lu)?(A="\t",lu++):(A=B,0===pu&&$u(_)),A===B&&(11===u.charCodeAt(lu)?(A="\v",lu++):(A=B,0===pu&&$u(G)),A===B&&(12===u.charCodeAt(lu)?(A="\f",lu++):(A=B,0===pu&&$u(H)),A===B&&(32===u.charCodeAt(lu)?(A=" ",lu++):(A=B,0===pu&&$u(R)),A===B&&(160===u.charCodeAt(lu)?(A=" ",lu++):(A=B,0===pu&&$u(I)),A===B&&(65279===u.charCodeAt(lu)?(A="\ufeff",lu++):(A=B,0===pu&&$u(K)),A===B&&(A=function(){var A,E=32*lu+31,C=du[E];return C?(lu=C.nextPos,C.result):(d.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(cu)),du[E]={nextPos:lu,result:A},A)}())))))),pu--,A===B&&0===pu&&$u(U),du[E]={nextPos:lu,result:A},A)}function Ju(){var A,E=32*lu+18,C=du[E];return C?(lu=C.nextPos,C.result):(n.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(T)),du[E]={nextPos:lu,result:A},A)}function Nu(){var A,E=32*lu+19,C=du[E];return C?(lu=C.nextPos,C.result):(pu++,10===u.charCodeAt(lu)?(A="\n",lu++):(A=B,0===pu&&$u(W)),A===B&&("\r\n"===u.substr(lu,2)?(A="\r\n",lu+=2):(A=B,0===pu&&$u(X)),A===B&&(13===u.charCodeAt(lu)?(A="\r",lu++):(A=B,0===pu&&$u(Y)),A===B&&(8232===u.charCodeAt(lu)?(A="\u2028",lu++):(A=B,0===pu&&$u(uu)),A===B&&(8233===u.charCodeAt(lu)?(A="\u2029",lu++):(A=B,0===pu&&$u(Au)))))),pu--,A===B&&0===pu&&$u(V),du[E]={nextPos:lu,result:A},A)}function Qu(){var A,E,C,F,t,r,e=32*lu+20,D=du[e];if(D)return lu=D.nextPos,D.result;if(pu++,A=lu,35===u.charCodeAt(lu)?(E="#",lu++):(E=B,0===pu&&$u(Cu)),E!==B){for(C=[],F=lu,t=lu,pu++,r=Ju(),pu--,r===B?t=void 0:(lu=t,t=B),t!==B&&(r=ku())!==B?F=t=[t,r]:(lu=F,F=B);F!==B;)C.push(F),F=lu,t=lu,pu++,r=Ju(),pu--,r===B?t=void 0:(lu=t,t=B),t!==B&&(r=ku())!==B?F=t=[t,r]:(lu=F,F=B);A=E=[E,C]}else lu=A,A=B;return pu--,A===B&&(E=B,0===pu&&$u(Eu)),du[e]={nextPos:lu,result:A},A}function Uu(u){return{...u,source:mu(iu,lu).source}}if((E=D())!==B&&lu===u.length)return E;throw E!==B&&lu<u.length&&$u({type:"end"}),C=xu,F=hu<u.length?u.charAt(hu):null,t=hu<u.length?mu(hu,hu+1):mu(hu,hu),new peg$SyntaxError(peg$SyntaxError.buildMessage(C,F),C,F,t)}peg$subclass(peg$SyntaxError,Error),peg$SyntaxError.prototype.format=function(u){var A="Error: "+this.message;if(this.location){var E,C=null;for(E=0;E<u.length;E++)if(u[E].source===this.location.source){C=u[E].text.split(/\r\n|\n|\r/g);break}var F=this.location.start,t=this.location.source+":"+F.line+":"+F.column;if(C){var B=this.location.end,r=peg$padEnd("",F.line.toString().length),e=C[F.line-1],D=F.line===B.line?B.column:e.length+1;A+="\n --\x3e "+t+"\n"+r+" |\n"+F.line+" | "+e+"\n"+r+" | "+peg$padEnd("",F.column-1)+peg$padEnd("",D-F.column,"^")}else A+="\n at "+t}return A},peg$SyntaxError.buildMessage=function(u,A){var E={literal:function(u){return'"'+F(u.text)+'"'},class:function(u){var A=u.parts.map((function(u){return Array.isArray(u)?t(u[0])+"-"+t(u[1]):t(u)}));return"["+(u.inverted?"^":"")+A+"]"},any:function(){return"any character"},end:function(){return"end of input"},other:function(u){return u.description}};function C(u){return u.charCodeAt(0).toString(16).toUpperCase()}function F(u){return u.replace(/\\/g,"\\\\").replace(/"/g,'\\"').replace(/\0/g,"\\0").replace(/\t/g,"\\t").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/[\x00-\x0F]/g,(function(u){return"\\x0"+C(u)})).replace(/[\x10-\x1F\x7F-\x9F]/g,(function(u){return"\\x"+C(u)}))}function t(u){return u.replace(/\\/g,"\\\\").replace(/\]/g,"\\]").replace(/\^/g,"\\^").replace(/-/g,"\\-").replace(/\0/g,"\\0").replace(/\t/g,"\\t").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/[\x00-\x0F]/g,(function(u){return"\\x0"+C(u)})).replace(/[\x10-\x1F\x7F-\x9F]/g,(function(u){return"\\x"+C(u)}))}function B(u){return E[u.type](u)}return"Expected "+function(u){var A,E,C=u.map(B);if(C.sort(),C.length>0){for(A=1,E=1;A<C.length;A++)C[A-1]!==C[A]&&(C[E]=C[A],E++);C.length=E}switch(C.length){case 1:return C[0];case 2:return C[0]+" or "+C[1];default:return C.slice(0,-1).join(", ")+", or "+C[C.length-1]}}(u)+" but "+function(u){return u?'"'+F(u)+'"':"end of input"}(A)+" found."};
+// 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
+function peg$subclass(u,A){function E(){this.constructor=u}E.prototype=A.prototype,u.prototype=new E}function peg$SyntaxError(u,A,E,C){var F=Error.call(this,u);return Object.setPrototypeOf&&Object.setPrototypeOf(F,peg$SyntaxError.prototype),F.expected=A,F.found=E,F.location=C,F.name="SyntaxError",F}function peg$padEnd(u,A,E){return E=E||" ",u.length>A?u:(A-=u.length,u+(E+=E.repeat(A)).slice(0,A))}function peg$parse(u,A){var E,C,F,t,B={},r=(A=void 0!==A?A:{}).grammarSource,e={Jungle:Su},D=Su,n=/^[\n\r\u2028\u2029]/,o=/^[a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137-\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148-\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C-\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA-\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC-\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF-\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F-\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0-\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB-\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE-\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0560-\u0588\u10D0-\u10FA\u10FD-\u10FF\u13F8-\u13FD\u1C80-\u1C88\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6-\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FC7\u1FD0-\u1FD3\u1FD6-\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6-\u1FF7\u210A\u210E-\u210F\u2113\u212F\u2134\u2139\u213C-\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65-\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73-\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7AF\uA7B5\uA7B7\uA7B9\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A]/,s=/^[\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5-\u06E6\u07F4-\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C-\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D-\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C-\uA69D\uA717-\uA71F\uA770\uA788\uA7F8-\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3-\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E-\uFF9F]/,a=/^[\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05EF-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u09FC\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u1100-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEF\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD-\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,c=/^[\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC]/,l=/^[A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178-\u0179\u017B\u017D\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018B\u018E-\u0191\u0193-\u0194\u0196-\u0198\u019C-\u019D\u019F-\u01A0\u01A2\u01A4\u01A6-\u01A7\u01A9\u01AC\u01AE-\u01AF\u01B1-\u01B3\u01B5\u01B7-\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A-\u023B\u023D-\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9-\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0-\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1C90-\u1CBA\u1CBD-\u1CBF\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E-\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D-\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AE\uA7B0-\uA7B4\uA7B6\uA7B8\uFF21-\uFF3A]/,i=/^[\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0982-\u0983\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0B02-\u0B03\u0B3E\u0B40\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82-\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0D02-\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82-\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2-\u0DF3\u0F3E-\u0F3F\u0F7F\u102B-\u102C\u1031\u1038\u103B-\u103C\u1056-\u1057\u1062-\u1064\u1067-\u106D\u1083-\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7-\u17C8\u1923-\u1926\u1929-\u192B\u1930-\u1931\u1933-\u1938\u1A19-\u1A1A\u1A55\u1A57\u1A61\u1A63-\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B82\u1BA1\u1BA6-\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1C24-\u1C2B\u1C34-\u1C35\u1CE1\u1CF2-\u1CF3\u1CF7\u302E-\u302F\uA823-\uA824\uA827\uA880-\uA881\uA8B4-\uA8C3\uA952-\uA953\uA983\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uAA2F-\uAA30\uAA33-\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE-\uAAEF\uAAF5\uABE3-\uABE4\uABE6-\uABE7\uABE9-\uABEA\uABEC]/,f=/^[\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7-\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962-\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2-\u09E3\u09FE\u0A01-\u0A02\u0A3C\u0A41-\u0A42\u0A47-\u0A48\u0A4B-\u0A4D\u0A51\u0A70-\u0A71\u0A75\u0A81-\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7-\u0AC8\u0ACD\u0AE2-\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B56\u0B62-\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55-\u0C56\u0C62-\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC-\u0CCD\u0CE2-\u0CE3\u0D00-\u0D01\u0D3B-\u0D3C\u0D41-\u0D44\u0D4D\u0D62-\u0D63\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB-\u0EBC\u0EC8-\u0ECD\u0F18-\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86-\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039-\u103A\u103D-\u103E\u1058-\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17B4-\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885-\u1886\u18A9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193B\u1A17-\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80-\u1B81\u1BA2-\u1BA5\u1BA8-\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8-\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099-\u309A\uA66F\uA674-\uA67D\uA69E-\uA69F\uA6F0-\uA6F1\uA802\uA806\uA80B\uA825-\uA826\uA8C4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9E5\uAA29-\uAA2E\uAA31-\uAA32\uAA35-\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7-\uAAB8\uAABE-\uAABF\uAAC1\uAAEC-\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/,h=/^[0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19]/,x=/^[\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF]/,p=/^[_\u203F-\u2040\u2054\uFE33-\uFE34\uFE4D-\uFE4F\uFF3F]/,d=/^[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/,P={type:"any"},g=Pu("=",!1),v=Pu(".",!1),y=Pu(";",!1),m=Pu("$(",!1),$=Pu(")",!1),S=vu("raw string"),b=vu("quoted string"),w=Pu('"',!1),j=Pu("[",!1),O=Pu("]",!1),R=Pu(" ",!1),_=Pu("\t",!1),L=Pu("\\",!1),z=vu("identifier"),M=Pu("_",!1),Z=Pu("$",!1),k=Pu("-",!1),q=Pu("‌",!1),J=Pu("‍",!1),N=Pu("/",!1),Q=Pu("*",!1),U=vu("whitespace"),G=Pu("\v",!1),H=Pu("\f",!1),I=Pu(" ",!1),K=Pu("\ufeff",!1),T=gu(["\n","\r","\u2028","\u2029"],!1,!1),V=vu("end of line"),W=Pu("\n",!1),X=Pu("\r\n",!1),Y=Pu("\r",!1),uu=Pu("\u2028",!1),Au=Pu("\u2029",!1),Eu=vu("comment"),Cu=Pu("#",!1),Fu=gu([["a","z"],"µ",["ß","ö"],["ø","ÿ"],"ā","ă","ą","ć","ĉ","ċ","č","ď","đ","ē","ĕ","ė","ę","ě","ĝ","ğ","ġ","ģ","ĥ","ħ","ĩ","ī","ĭ","į","ı","ij","ĵ",["ķ","ĸ"],"ĺ","ļ","ľ","ŀ","ł","ń","ņ",["ň","ʼn"],"ŋ","ō","ŏ","ő","œ","ŕ","ŗ","ř","ś","ŝ","ş","š","ţ","ť","ŧ","ũ","ū","ŭ","ů","ű","ų","ŵ","ŷ","ź","ż",["ž","ƀ"],"ƃ","ƅ","ƈ",["ƌ","ƍ"],"ƒ","ƕ",["ƙ","ƛ"],"ƞ","ơ","ƣ","ƥ","ƨ",["ƪ","ƫ"],"ƭ","ư","ƴ","ƶ",["ƹ","ƺ"],["ƽ","ƿ"],"dž","lj","nj","ǎ","ǐ","ǒ","ǔ","ǖ","ǘ","ǚ",["ǜ","ǝ"],"ǟ","ǡ","ǣ","ǥ","ǧ","ǩ","ǫ","ǭ",["ǯ","ǰ"],"dz","ǵ","ǹ","ǻ","ǽ","ǿ","ȁ","ȃ","ȅ","ȇ","ȉ","ȋ","ȍ","ȏ","ȑ","ȓ","ȕ","ȗ","ș","ț","ȝ","ȟ","ȡ","ȣ","ȥ","ȧ","ȩ","ȫ","ȭ","ȯ","ȱ",["ȳ","ȹ"],"ȼ",["ȿ","ɀ"],"ɂ","ɇ","ɉ","ɋ","ɍ",["ɏ","ʓ"],["ʕ","ʯ"],"ͱ","ͳ","ͷ",["ͻ","ͽ"],"ΐ",["ά","ώ"],["ϐ","ϑ"],["ϕ","ϗ"],"ϙ","ϛ","ϝ","ϟ","ϡ","ϣ","ϥ","ϧ","ϩ","ϫ","ϭ",["ϯ","ϳ"],"ϵ","ϸ",["ϻ","ϼ"],["а","џ"],"ѡ","ѣ","ѥ","ѧ","ѩ","ѫ","ѭ","ѯ","ѱ","ѳ","ѵ","ѷ","ѹ","ѻ","ѽ","ѿ","ҁ","ҋ","ҍ","ҏ","ґ","ғ","ҕ","җ","ҙ","қ","ҝ","ҟ","ҡ","ң","ҥ","ҧ","ҩ","ҫ","ҭ","ү","ұ","ҳ","ҵ","ҷ","ҹ","һ","ҽ","ҿ","ӂ","ӄ","ӆ","ӈ","ӊ","ӌ",["ӎ","ӏ"],"ӑ","ӓ","ӕ","ӗ","ә","ӛ","ӝ","ӟ","ӡ","ӣ","ӥ","ӧ","ө","ӫ","ӭ","ӯ","ӱ","ӳ","ӵ","ӷ","ӹ","ӻ","ӽ","ӿ","ԁ","ԃ","ԅ","ԇ","ԉ","ԋ","ԍ","ԏ","ԑ","ԓ","ԕ","ԗ","ԙ","ԛ","ԝ","ԟ","ԡ","ԣ","ԥ","ԧ","ԩ","ԫ","ԭ","ԯ",["ՠ","ֈ"],["ა","ჺ"],["ჽ","ჿ"],["ᏸ","ᏽ"],["ᲀ","ᲈ"],["ᴀ","ᴫ"],["ᵫ","ᵷ"],["ᵹ","ᶚ"],"ḁ","ḃ","ḅ","ḇ","ḉ","ḋ","ḍ","ḏ","ḑ","ḓ","ḕ","ḗ","ḙ","ḛ","ḝ","ḟ","ḡ","ḣ","ḥ","ḧ","ḩ","ḫ","ḭ","ḯ","ḱ","ḳ","ḵ","ḷ","ḹ","ḻ","ḽ","ḿ","ṁ","ṃ","ṅ","ṇ","ṉ","ṋ","ṍ","ṏ","ṑ","ṓ","ṕ","ṗ","ṙ","ṛ","ṝ","ṟ","ṡ","ṣ","ṥ","ṧ","ṩ","ṫ","ṭ","ṯ","ṱ","ṳ","ṵ","ṷ","ṹ","ṻ","ṽ","ṿ","ẁ","ẃ","ẅ","ẇ","ẉ","ẋ","ẍ","ẏ","ẑ","ẓ",["ẕ","ẝ"],"ẟ","ạ","ả","ấ","ầ","ẩ","ẫ","ậ","ắ","ằ","ẳ","ẵ","ặ","ẹ","ẻ","ẽ","ế","ề","ể","ễ","ệ","ỉ","ị","ọ","ỏ","ố","ồ","ổ","ỗ","ộ","ớ","ờ","ở","ỡ","ợ","ụ","ủ","ứ","ừ","ử","ữ","ự","ỳ","ỵ","ỷ","ỹ","ỻ","ỽ",["ỿ","ἇ"],["ἐ","ἕ"],["ἠ","ἧ"],["ἰ","ἷ"],["ὀ","ὅ"],["ὐ","ὗ"],["ὠ","ὧ"],["ὰ","ώ"],["ᾀ","ᾇ"],["ᾐ","ᾗ"],["ᾠ","ᾧ"],["ᾰ","ᾴ"],["ᾶ","ᾷ"],"ι",["ῂ","ῄ"],["ῆ","ῇ"],["ῐ","ΐ"],["ῖ","ῗ"],["ῠ","ῧ"],["ῲ","ῴ"],["ῶ","ῷ"],"ℊ",["ℎ","ℏ"],"ℓ","ℯ","ℴ","ℹ",["ℼ","ℽ"],["ⅆ","ⅉ"],"ⅎ","ↄ",["ⰰ","ⱞ"],"ⱡ",["ⱥ","ⱦ"],"ⱨ","ⱪ","ⱬ","ⱱ",["ⱳ","ⱴ"],["ⱶ","ⱻ"],"ⲁ","ⲃ","ⲅ","ⲇ","ⲉ","ⲋ","ⲍ","ⲏ","ⲑ","ⲓ","ⲕ","ⲗ","ⲙ","ⲛ","ⲝ","ⲟ","ⲡ","ⲣ","ⲥ","ⲧ","ⲩ","ⲫ","ⲭ","ⲯ","ⲱ","ⲳ","ⲵ","ⲷ","ⲹ","ⲻ","ⲽ","ⲿ","ⳁ","ⳃ","ⳅ","ⳇ","ⳉ","ⳋ","ⳍ","ⳏ","ⳑ","ⳓ","ⳕ","ⳗ","ⳙ","ⳛ","ⳝ","ⳟ","ⳡ",["ⳣ","ⳤ"],"ⳬ","ⳮ","ⳳ",["ⴀ","ⴥ"],"ⴧ","ⴭ","ꙁ","ꙃ","ꙅ","ꙇ","ꙉ","ꙋ","ꙍ","ꙏ","ꙑ","ꙓ","ꙕ","ꙗ","ꙙ","ꙛ","ꙝ","ꙟ","ꙡ","ꙣ","ꙥ","ꙧ","ꙩ","ꙫ","ꙭ","ꚁ","ꚃ","ꚅ","ꚇ","ꚉ","ꚋ","ꚍ","ꚏ","ꚑ","ꚓ","ꚕ","ꚗ","ꚙ","ꚛ","ꜣ","ꜥ","ꜧ","ꜩ","ꜫ","ꜭ",["ꜯ","ꜱ"],"ꜳ","ꜵ","ꜷ","ꜹ","ꜻ","ꜽ","ꜿ","ꝁ","ꝃ","ꝅ","ꝇ","ꝉ","ꝋ","ꝍ","ꝏ","ꝑ","ꝓ","ꝕ","ꝗ","ꝙ","ꝛ","ꝝ","ꝟ","ꝡ","ꝣ","ꝥ","ꝧ","ꝩ","ꝫ","ꝭ","ꝯ",["ꝱ","ꝸ"],"ꝺ","ꝼ","ꝿ","ꞁ","ꞃ","ꞅ","ꞇ","ꞌ","ꞎ","ꞑ",["ꞓ","ꞕ"],"ꞗ","ꞙ","ꞛ","ꞝ","ꞟ","ꞡ","ꞣ","ꞥ","ꞧ","ꞩ","ꞯ","ꞵ","ꞷ","ꞹ","ꟺ",["ꬰ","ꭚ"],["ꭠ","ꭥ"],["ꭰ","ꮿ"],["ff","st"],["ﬓ","ﬗ"],["ａ","ｚ"]],!1,!1),tu=gu([["ʰ","ˁ"],["ˆ","ˑ"],["ˠ","ˤ"],"ˬ","ˮ","ʹ","ͺ","ՙ","ـ",["ۥ","ۦ"],["ߴ","ߵ"],"ߺ","ࠚ","ࠤ","ࠨ","ॱ","ๆ","ໆ","ჼ","ៗ","ᡃ","ᪧ",["ᱸ","ᱽ"],["ᴬ","ᵪ"],"ᵸ",["ᶛ","ᶿ"],"ⁱ","ⁿ",["ₐ","ₜ"],["ⱼ","ⱽ"],"ⵯ","ⸯ","々",["〱","〵"],"〻",["ゝ","ゞ"],["ー","ヾ"],"ꀕ",["ꓸ","ꓽ"],"ꘌ","ꙿ",["ꚜ","ꚝ"],["ꜗ","ꜟ"],"ꝰ","ꞈ",["ꟸ","ꟹ"],"ꧏ","ꧦ","ꩰ","ꫝ",["ꫳ","ꫴ"],["ꭜ","ꭟ"],"ｰ",["ﾞ","ﾟ"]],!1,!1),Bu=gu(["ª","º","ƻ",["ǀ","ǃ"],"ʔ",["א","ת"],["ׯ","ײ"],["ؠ","ؿ"],["ف","ي"],["ٮ","ٯ"],["ٱ","ۓ"],"ە",["ۮ","ۯ"],["ۺ","ۼ"],"ۿ","ܐ",["ܒ","ܯ"],["ݍ","ޥ"],"ޱ",["ߊ","ߪ"],["ࠀ","ࠕ"],["ࡀ","ࡘ"],["ࡠ","ࡪ"],["ࢠ","ࢴ"],["ࢶ","ࢽ"],["ऄ","ह"],"ऽ","ॐ",["क़","ॡ"],["ॲ","ঀ"],["অ","ঌ"],["এ","ঐ"],["ও","ন"],["প","র"],"ল",["শ","হ"],"ঽ","ৎ",["ড়","ঢ়"],["য়","ৡ"],["ৰ","ৱ"],"ৼ",["ਅ","ਊ"],["ਏ","ਐ"],["ਓ","ਨ"],["ਪ","ਰ"],["ਲ","ਲ਼"],["ਵ","ਸ਼"],["ਸ","ਹ"],["ਖ਼","ੜ"],"ਫ਼",["ੲ","ੴ"],["અ","ઍ"],["એ","ઑ"],["ઓ","ન"],["પ","ર"],["લ","ળ"],["વ","હ"],"ઽ","ૐ",["ૠ","ૡ"],"ૹ",["ଅ","ଌ"],["ଏ","ଐ"],["ଓ","ନ"],["ପ","ର"],["ଲ","ଳ"],["ଵ","ହ"],"ଽ",["ଡ଼","ଢ଼"],["ୟ","ୡ"],"ୱ","ஃ",["அ","ஊ"],["எ","ஐ"],["ஒ","க"],["ங","ச"],"ஜ",["ஞ","ட"],["ண","த"],["ந","ப"],["ம","ஹ"],"ௐ",["అ","ఌ"],["ఎ","ఐ"],["ఒ","న"],["ప","హ"],"ఽ",["ౘ","ౚ"],["ౠ","ౡ"],"ಀ",["ಅ","ಌ"],["ಎ","ಐ"],["ಒ","ನ"],["ಪ","ಳ"],["ವ","ಹ"],"ಽ","ೞ",["ೠ","ೡ"],["ೱ","ೲ"],["അ","ഌ"],["എ","ഐ"],["ഒ","ഺ"],"ഽ","ൎ",["ൔ","ൖ"],["ൟ","ൡ"],["ൺ","ൿ"],["අ","ඖ"],["ක","න"],["ඳ","ර"],"ල",["ව","ෆ"],["ก","ะ"],["า","ำ"],["เ","ๅ"],["ກ","ຂ"],"ຄ",["ງ","ຈ"],"ຊ","ຍ",["ດ","ທ"],["ນ","ຟ"],["ມ","ຣ"],"ລ","ວ",["ສ","ຫ"],["ອ","ະ"],["າ","ຳ"],"ຽ",["ເ","ໄ"],["ໜ","ໟ"],"ༀ",["ཀ","ཇ"],["ཉ","ཬ"],["ྈ","ྌ"],["က","ဪ"],"ဿ",["ၐ","ၕ"],["ၚ","ၝ"],"ၡ",["ၥ","ၦ"],["ၮ","ၰ"],["ၵ","ႁ"],"ႎ",["ᄀ","ቈ"],["ቊ","ቍ"],["ቐ","ቖ"],"ቘ",["ቚ","ቝ"],["በ","ኈ"],["ኊ","ኍ"],["ነ","ኰ"],["ኲ","ኵ"],["ኸ","ኾ"],"ዀ",["ዂ","ዅ"],["ወ","ዖ"],["ዘ","ጐ"],["ጒ","ጕ"],["ጘ","ፚ"],["ᎀ","ᎏ"],["ᐁ","ᙬ"],["ᙯ","ᙿ"],["ᚁ","ᚚ"],["ᚠ","ᛪ"],["ᛱ","ᛸ"],["ᜀ","ᜌ"],["ᜎ","ᜑ"],["ᜠ","ᜱ"],["ᝀ","ᝑ"],["ᝠ","ᝬ"],["ᝮ","ᝰ"],["ក","ឳ"],"ៜ",["ᠠ","ᡂ"],["ᡄ","ᡸ"],["ᢀ","ᢄ"],["ᢇ","ᢨ"],"ᢪ",["ᢰ","ᣵ"],["ᤀ","ᤞ"],["ᥐ","ᥭ"],["ᥰ","ᥴ"],["ᦀ","ᦫ"],["ᦰ","ᧉ"],["ᨀ","ᨖ"],["ᨠ","ᩔ"],["ᬅ","ᬳ"],["ᭅ","ᭋ"],["ᮃ","ᮠ"],["ᮮ","ᮯ"],["ᮺ","ᯥ"],["ᰀ","ᰣ"],["ᱍ","ᱏ"],["ᱚ","ᱷ"],["ᳩ","ᳬ"],["ᳮ","ᳱ"],["ᳵ","ᳶ"],["ℵ","ℸ"],["ⴰ","ⵧ"],["ⶀ","ⶖ"],["ⶠ","ⶦ"],["ⶨ","ⶮ"],["ⶰ","ⶶ"],["ⶸ","ⶾ"],["ⷀ","ⷆ"],["ⷈ","ⷎ"],["ⷐ","ⷖ"],["ⷘ","ⷞ"],"〆","〼",["ぁ","ゖ"],"ゟ",["ァ","ヺ"],"ヿ",["ㄅ","ㄯ"],["ㄱ","ㆎ"],["ㆠ","ㆺ"],["ㇰ","ㇿ"],["㐀","䶵"],["一","鿯"],["ꀀ","ꀔ"],["ꀖ","ꒌ"],["ꓐ","ꓷ"],["ꔀ","ꘋ"],["ꘐ","ꘟ"],["ꘪ","ꘫ"],"ꙮ",["ꚠ","ꛥ"],"ꞏ","ꟷ",["ꟻ","ꠁ"],["ꠃ","ꠅ"],["ꠇ","ꠊ"],["ꠌ","ꠢ"],["ꡀ","ꡳ"],["ꢂ","ꢳ"],["ꣲ","ꣷ"],"ꣻ",["ꣽ","ꣾ"],["ꤊ","ꤥ"],["ꤰ","ꥆ"],["ꥠ","ꥼ"],["ꦄ","ꦲ"],["ꧠ","ꧤ"],["ꧧ","ꧯ"],["ꧺ","ꧾ"],["ꨀ","ꨨ"],["ꩀ","ꩂ"],["ꩄ","ꩋ"],["ꩠ","ꩯ"],["ꩱ","ꩶ"],"ꩺ",["ꩾ","ꪯ"],"ꪱ",["ꪵ","ꪶ"],["ꪹ","ꪽ"],"ꫀ","ꫂ",["ꫛ","ꫜ"],["ꫠ","ꫪ"],"ꫲ",["ꬁ","ꬆ"],["ꬉ","ꬎ"],["ꬑ","ꬖ"],["ꬠ","ꬦ"],["ꬨ","ꬮ"],["ꯀ","ꯢ"],["가","힣"],["ힰ","ퟆ"],["ퟋ","ퟻ"],["豈","舘"],["並","龎"],"יִ",["ײַ","ﬨ"],["שׁ","זּ"],["טּ","לּ"],"מּ",["נּ","סּ"],["ףּ","פּ"],["צּ","ﮱ"],["ﯓ","ﴽ"],["ﵐ","ﶏ"],["ﶒ","ﷇ"],["ﷰ","ﷻ"],["ﹰ","ﹴ"],["ﹶ","ﻼ"],["ｦ","ｯ"],["ｱ","ﾝ"],["ﾠ","ﾾ"],["ￂ","ￇ"],["ￊ","ￏ"],["ￒ","ￗ"],["ￚ","ￜ"]],!1,!1),ru=gu(["Dž","Lj","Nj","Dz",["ᾈ","ᾏ"],["ᾘ","ᾟ"],["ᾨ","ᾯ"],"ᾼ","ῌ","ῼ"],!1,!1),eu=gu([["A","Z"],["À","Ö"],["Ø","Þ"],"Ā","Ă","Ą","Ć","Ĉ","Ċ","Č","Ď","Đ","Ē","Ĕ","Ė","Ę","Ě","Ĝ","Ğ","Ġ","Ģ","Ĥ","Ħ","Ĩ","Ī","Ĭ","Į","İ","IJ","Ĵ","Ķ","Ĺ","Ļ","Ľ","Ŀ","Ł","Ń","Ņ","Ň","Ŋ","Ō","Ŏ","Ő","Œ","Ŕ","Ŗ","Ř","Ś","Ŝ","Ş","Š","Ţ","Ť","Ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","Ŵ","Ŷ",["Ÿ","Ź"],"Ż","Ž",["Ɓ","Ƃ"],"Ƅ",["Ɔ","Ƈ"],["Ɖ","Ƌ"],["Ǝ","Ƒ"],["Ɠ","Ɣ"],["Ɩ","Ƙ"],["Ɯ","Ɲ"],["Ɵ","Ơ"],"Ƣ","Ƥ",["Ʀ","Ƨ"],"Ʃ","Ƭ",["Ʈ","Ư"],["Ʊ","Ƴ"],"Ƶ",["Ʒ","Ƹ"],"Ƽ","DŽ","LJ","NJ","Ǎ","Ǐ","Ǒ","Ǔ","Ǖ","Ǘ","Ǚ","Ǜ","Ǟ","Ǡ","Ǣ","Ǥ","Ǧ","Ǩ","Ǫ","Ǭ","Ǯ","DZ","Ǵ",["Ƕ","Ǹ"],"Ǻ","Ǽ","Ǿ","Ȁ","Ȃ","Ȅ","Ȇ","Ȉ","Ȋ","Ȍ","Ȏ","Ȑ","Ȓ","Ȕ","Ȗ","Ș","Ț","Ȝ","Ȟ","Ƞ","Ȣ","Ȥ","Ȧ","Ȩ","Ȫ","Ȭ","Ȯ","Ȱ","Ȳ",["Ⱥ","Ȼ"],["Ƚ","Ⱦ"],"Ɂ",["Ƀ","Ɇ"],"Ɉ","Ɋ","Ɍ","Ɏ","Ͱ","Ͳ","Ͷ","Ϳ","Ά",["Έ","Ί"],"Ό",["Ύ","Ώ"],["Α","Ρ"],["Σ","Ϋ"],"Ϗ",["ϒ","ϔ"],"Ϙ","Ϛ","Ϝ","Ϟ","Ϡ","Ϣ","Ϥ","Ϧ","Ϩ","Ϫ","Ϭ","Ϯ","ϴ","Ϸ",["Ϲ","Ϻ"],["Ͻ","Я"],"Ѡ","Ѣ","Ѥ","Ѧ","Ѩ","Ѫ","Ѭ","Ѯ","Ѱ","Ѳ","Ѵ","Ѷ","Ѹ","Ѻ","Ѽ","Ѿ","Ҁ","Ҋ","Ҍ","Ҏ","Ґ","Ғ","Ҕ","Җ","Ҙ","Қ","Ҝ","Ҟ","Ҡ","Ң","Ҥ","Ҧ","Ҩ","Ҫ","Ҭ","Ү","Ұ","Ҳ","Ҵ","Ҷ","Ҹ","Һ","Ҽ","Ҿ",["Ӏ","Ӂ"],"Ӄ","Ӆ","Ӈ","Ӊ","Ӌ","Ӎ","Ӑ","Ӓ","Ӕ","Ӗ","Ә","Ӛ","Ӝ","Ӟ","Ӡ","Ӣ","Ӥ","Ӧ","Ө","Ӫ","Ӭ","Ӯ","Ӱ","Ӳ","Ӵ","Ӷ","Ӹ","Ӻ","Ӽ","Ӿ","Ԁ","Ԃ","Ԅ","Ԇ","Ԉ","Ԋ","Ԍ","Ԏ","Ԑ","Ԓ","Ԕ","Ԗ","Ԙ","Ԛ","Ԝ","Ԟ","Ԡ","Ԣ","Ԥ","Ԧ","Ԩ","Ԫ","Ԭ","Ԯ",["Ա","Ֆ"],["Ⴀ","Ⴥ"],"Ⴧ","Ⴭ",["Ꭰ","Ᏽ"],["Ა","Ჺ"],["Ჽ","Ჿ"],"Ḁ","Ḃ","Ḅ","Ḇ","Ḉ","Ḋ","Ḍ","Ḏ","Ḑ","Ḓ","Ḕ","Ḗ","Ḙ","Ḛ","Ḝ","Ḟ","Ḡ","Ḣ","Ḥ","Ḧ","Ḩ","Ḫ","Ḭ","Ḯ","Ḱ","Ḳ","Ḵ","Ḷ","Ḹ","Ḻ","Ḽ","Ḿ","Ṁ","Ṃ","Ṅ","Ṇ","Ṉ","Ṋ","Ṍ","Ṏ","Ṑ","Ṓ","Ṕ","Ṗ","Ṙ","Ṛ","Ṝ","Ṟ","Ṡ","Ṣ","Ṥ","Ṧ","Ṩ","Ṫ","Ṭ","Ṯ","Ṱ","Ṳ","Ṵ","Ṷ","Ṹ","Ṻ","Ṽ","Ṿ","Ẁ","Ẃ","Ẅ","Ẇ","Ẉ","Ẋ","Ẍ","Ẏ","Ẑ","Ẓ","Ẕ","ẞ","Ạ","Ả","Ấ","Ầ","Ẩ","Ẫ","Ậ","Ắ","Ằ","Ẳ","Ẵ","Ặ","Ẹ","Ẻ","Ẽ","Ế","Ề","Ể","Ễ","Ệ","Ỉ","Ị","Ọ","Ỏ","Ố","Ồ","Ổ","Ỗ","Ộ","Ớ","Ờ","Ở","Ỡ","Ợ","Ụ","Ủ","Ứ","Ừ","Ử","Ữ","Ự","Ỳ","Ỵ","Ỷ","Ỹ","Ỻ","Ỽ","Ỿ",["Ἀ","Ἇ"],["Ἐ","Ἕ"],["Ἠ","Ἧ"],["Ἰ","Ἷ"],["Ὀ","Ὅ"],"Ὑ","Ὓ","Ὕ","Ὗ",["Ὠ","Ὧ"],["Ᾰ","Ά"],["Ὲ","Ή"],["Ῐ","Ί"],["Ῠ","Ῥ"],["Ὸ","Ώ"],"ℂ","ℇ",["ℋ","ℍ"],["ℐ","ℒ"],"ℕ",["ℙ","ℝ"],"ℤ","Ω","ℨ",["K","ℭ"],["ℰ","ℳ"],["ℾ","ℿ"],"ⅅ","Ↄ",["Ⰰ","Ⱞ"],"Ⱡ",["Ɫ","Ɽ"],"Ⱨ","Ⱪ","Ⱬ",["Ɑ","Ɒ"],"Ⱳ","Ⱶ",["Ȿ","Ⲁ"],"Ⲃ","Ⲅ","Ⲇ","Ⲉ","Ⲋ","Ⲍ","Ⲏ","Ⲑ","Ⲓ","Ⲕ","Ⲗ","Ⲙ","Ⲛ","Ⲝ","Ⲟ","Ⲡ","Ⲣ","Ⲥ","Ⲧ","Ⲩ","Ⲫ","Ⲭ","Ⲯ","Ⲱ","Ⲳ","Ⲵ","Ⲷ","Ⲹ","Ⲻ","Ⲽ","Ⲿ","Ⳁ","Ⳃ","Ⳅ","Ⳇ","Ⳉ","Ⳋ","Ⳍ","Ⳏ","Ⳑ","Ⳓ","Ⳕ","Ⳗ","Ⳙ","Ⳛ","Ⳝ","Ⳟ","Ⳡ","Ⳣ","Ⳬ","Ⳮ","Ⳳ","Ꙁ","Ꙃ","Ꙅ","Ꙇ","Ꙉ","Ꙋ","Ꙍ","Ꙏ","Ꙑ","Ꙓ","Ꙕ","Ꙗ","Ꙙ","Ꙛ","Ꙝ","Ꙟ","Ꙡ","Ꙣ","Ꙥ","Ꙧ","Ꙩ","Ꙫ","Ꙭ","Ꚁ","Ꚃ","Ꚅ","Ꚇ","Ꚉ","Ꚋ","Ꚍ","Ꚏ","Ꚑ","Ꚓ","Ꚕ","Ꚗ","Ꚙ","Ꚛ","Ꜣ","Ꜥ","Ꜧ","Ꜩ","Ꜫ","Ꜭ","Ꜯ","Ꜳ","Ꜵ","Ꜷ","Ꜹ","Ꜻ","Ꜽ","Ꜿ","Ꝁ","Ꝃ","Ꝅ","Ꝇ","Ꝉ","Ꝋ","Ꝍ","Ꝏ","Ꝑ","Ꝓ","Ꝕ","Ꝗ","Ꝙ","Ꝛ","Ꝝ","Ꝟ","Ꝡ","Ꝣ","Ꝥ","Ꝧ","Ꝩ","Ꝫ","Ꝭ","Ꝯ","Ꝺ","Ꝼ",["Ᵹ","Ꝿ"],"Ꞁ","Ꞃ","Ꞅ","Ꞇ","Ꞌ","Ɥ","Ꞑ","Ꞓ","Ꞗ","Ꞙ","Ꞛ","Ꞝ","Ꞟ","Ꞡ","Ꞣ","Ꞥ","Ꞧ","Ꞩ",["Ɦ","Ɪ"],["Ʞ","Ꞵ"],"Ꞷ","Ꞹ",["Ａ","Ｚ"]],!1,!1),Du=gu(["ः","ऻ",["ा","ी"],["ॉ","ौ"],["ॎ","ॏ"],["ং","ঃ"],["া","ী"],["ে","ৈ"],["ো","ৌ"],"ৗ","ਃ",["ਾ","ੀ"],"ઃ",["ા","ી"],"ૉ",["ો","ૌ"],["ଂ","ଃ"],"ା","ୀ",["େ","ୈ"],["ୋ","ୌ"],"ୗ",["ா","ி"],["ு","ூ"],["ெ","ை"],["ொ","ௌ"],"ௗ",["ఁ","ః"],["ు","ౄ"],["ಂ","ಃ"],"ಾ",["ೀ","ೄ"],["ೇ","ೈ"],["ೊ","ೋ"],["ೕ","ೖ"],["ം","ഃ"],["ാ","ീ"],["െ","ൈ"],["ൊ","ൌ"],"ൗ",["ං","ඃ"],["ා","ෑ"],["ෘ","ෟ"],["ෲ","ෳ"],["༾","༿"],"ཿ",["ါ","ာ"],"ေ","း",["ျ","ြ"],["ၖ","ၗ"],["ၢ","ၤ"],["ၧ","ၭ"],["ႃ","ႄ"],["ႇ","ႌ"],"ႏ",["ႚ","ႜ"],"ា",["ើ","ៅ"],["ះ","ៈ"],["ᤣ","ᤦ"],["ᤩ","ᤫ"],["ᤰ","ᤱ"],["ᤳ","ᤸ"],["ᨙ","ᨚ"],"ᩕ","ᩗ","ᩡ",["ᩣ","ᩤ"],["ᩭ","ᩲ"],"ᬄ","ᬵ","ᬻ",["ᬽ","ᭁ"],["ᭃ","᭄"],"ᮂ","ᮡ",["ᮦ","ᮧ"],"᮪","ᯧ",["ᯪ","ᯬ"],"ᯮ",["᯲","᯳"],["ᰤ","ᰫ"],["ᰴ","ᰵ"],"᳡",["ᳲ","ᳳ"],"᳷",["〮","〯"],["ꠣ","ꠤ"],"ꠧ",["ꢀ","ꢁ"],["ꢴ","ꣃ"],["ꥒ","꥓"],"ꦃ",["ꦴ","ꦵ"],["ꦺ","ꦻ"],["ꦽ","꧀"],["ꨯ","ꨰ"],["ꨳ","ꨴ"],"ꩍ","ꩻ","ꩽ","ꫫ",["ꫮ","ꫯ"],"ꫵ",["ꯣ","ꯤ"],["ꯦ","ꯧ"],["ꯩ","ꯪ"],"꯬"],!1,!1),nu=gu([["̀","ͯ"],["҃","҇"],["֑","ֽ"],"ֿ",["ׁ","ׂ"],["ׄ","ׅ"],"ׇ",["ؐ","ؚ"],["ً","ٟ"],"ٰ",["ۖ","ۜ"],["۟","ۤ"],["ۧ","ۨ"],["۪","ۭ"],"ܑ",["ܰ","݊"],["ަ","ް"],["߫","߳"],"߽",["ࠖ","࠙"],["ࠛ","ࠣ"],["ࠥ","ࠧ"],["ࠩ","࠭"],["࡙","࡛"],["࣓","࣡"],["ࣣ","ं"],"ऺ","़",["ु","ै"],"्",["॑","ॗ"],["ॢ","ॣ"],"ঁ","়",["ু","ৄ"],"্",["ৢ","ৣ"],"৾",["ਁ","ਂ"],"਼",["ੁ","ੂ"],["ੇ","ੈ"],["ੋ","੍"],"ੑ",["ੰ","ੱ"],"ੵ",["ઁ","ં"],"઼",["ુ","ૅ"],["ે","ૈ"],"્",["ૢ","ૣ"],["ૺ","૿"],"ଁ","଼","ି",["ୁ","ୄ"],"୍","ୖ",["ୢ","ୣ"],"ஂ","ீ","்","ఀ","ఄ",["ా","ీ"],["ె","ై"],["ొ","్"],["ౕ","ౖ"],["ౢ","ౣ"],"ಁ","಼","ಿ","ೆ",["ೌ","್"],["ೢ","ೣ"],["ഀ","ഁ"],["഻","഼"],["ു","ൄ"],"്",["ൢ","ൣ"],"්",["ි","ු"],"ූ","ั",["ิ","ฺ"],["็","๎"],"ັ",["ິ","ູ"],["ົ","ຼ"],["່","ໍ"],["༘","༙"],"༵","༷","༹",["ཱ","ཾ"],["ྀ","྄"],["྆","྇"],["ྍ","ྗ"],["ྙ","ྼ"],"࿆",["ိ","ူ"],["ဲ","့"],["္","်"],["ွ","ှ"],["ၘ","ၙ"],["ၞ","ၠ"],["ၱ","ၴ"],"ႂ",["ႅ","ႆ"],"ႍ","ႝ",["፝","፟"],["ᜒ","᜔"],["ᜲ","᜴"],["ᝒ","ᝓ"],["ᝲ","ᝳ"],["឴","឵"],["ិ","ួ"],"ំ",["៉","៓"],"៝",["᠋","᠍"],["ᢅ","ᢆ"],"ᢩ",["ᤠ","ᤢ"],["ᤧ","ᤨ"],"ᤲ",["᤹","᤻"],["ᨗ","ᨘ"],"ᨛ","ᩖ",["ᩘ","ᩞ"],"᩠","ᩢ",["ᩥ","ᩬ"],["ᩳ","᩼"],"᩿",["᪰","᪽"],["ᬀ","ᬃ"],"᬴",["ᬶ","ᬺ"],"ᬼ","ᭂ",["᭫","᭳"],["ᮀ","ᮁ"],["ᮢ","ᮥ"],["ᮨ","ᮩ"],["᮫","ᮭ"],"᯦",["ᯨ","ᯩ"],"ᯭ",["ᯯ","ᯱ"],["ᰬ","ᰳ"],["ᰶ","᰷"],["᳐","᳒"],["᳔","᳠"],["᳢","᳨"],"᳭","᳴",["᳸","᳹"],["᷀","᷹"],["᷻","᷿"],["⃐","⃜"],"⃡",["⃥","⃰"],["⳯","⳱"],"⵿",["ⷠ","ⷿ"],["〪","〭"],["゙","゚"],"꙯",["ꙴ","꙽"],["ꚞ","ꚟ"],["꛰","꛱"],"ꠂ","꠆","ꠋ",["ꠥ","ꠦ"],["꣄","ꣅ"],["꣠","꣱"],"ꣿ",["ꤦ","꤭"],["ꥇ","ꥑ"],["ꦀ","ꦂ"],"꦳",["ꦶ","ꦹ"],"ꦼ","ꧥ",["ꨩ","ꨮ"],["ꨱ","ꨲ"],["ꨵ","ꨶ"],"ꩃ","ꩌ","ꩼ","ꪰ",["ꪲ","ꪴ"],["ꪷ","ꪸ"],["ꪾ","꪿"],"꫁",["ꫬ","ꫭ"],"꫶","ꯥ","ꯨ","꯭","ﬞ",["︀","️"],["︠","︯"]],!1,!1),ou=gu([["0","9"],["٠","٩"],["۰","۹"],["߀","߉"],["०","९"],["০","৯"],["੦","੯"],["૦","૯"],["୦","୯"],["௦","௯"],["౦","౯"],["೦","೯"],["൦","൯"],["෦","෯"],["๐","๙"],["໐","໙"],["༠","༩"],["၀","၉"],["႐","႙"],["០","៩"],["᠐","᠙"],["᥆","᥏"],["᧐","᧙"],["᪀","᪉"],["᪐","᪙"],["᭐","᭙"],["᮰","᮹"],["᱀","᱉"],["᱐","᱙"],["꘠","꘩"],["꣐","꣙"],["꤀","꤉"],["꧐","꧙"],["꧰","꧹"],["꩐","꩙"],["꯰","꯹"],["０","９"]],!1,!1),su=gu([["ᛮ","ᛰ"],["Ⅰ","ↂ"],["ↅ","ↈ"],"〇",["〡","〩"],["〸","〺"],["ꛦ","ꛯ"]],!1,!1),au=gu(["_",["‿","⁀"],"⁔",["︳","︴"],["﹍","﹏"],"＿"],!1,!1),cu=gu([" "," "," ",[" "," "]," "," ","　"],!1,!1),lu=0,iu=0,fu=[{line:1,column:1}],hu=0,xu=[],pu=0,du={};if("startRule"in A){if(!(A.startRule in e))throw new Error("Can't start parsing from rule \""+A.startRule+'".');D=e[A.startRule]}function Pu(u,A){return{type:"literal",text:u,ignoreCase:A}}function gu(u,A,E){return{type:"class",parts:u,inverted:A,ignoreCase:E}}function vu(u){return{type:"other",description:u}}function yu(A){var E,C=fu[A];if(C)return C;for(E=A-1;!fu[E];)E--;for(C={line:(C=fu[E]).line,column:C.column};E<A;)10===u.charCodeAt(E)?(C.line++,C.column=1):C.column++,E++;return fu[A]=C,C}function mu(u,A){var E=yu(u),C=yu(A);return{source:r,start:{offset:u,line:E.line,column:E.column},end:{offset:A,line:C.line,column:C.column}}}function $u(u){lu<hu||(lu>hu&&(hu=lu,xu=[]),xu.push(u))}function Su(){var A,E,C,F,t,r=32*lu+0,e=du[r];if(e)return lu=e.nextPos,e.result;for(A=lu,E=[],C=lu,F=Ru(),(t=bu())!==B?C=t:(lu=C,C=B);C!==B;)E.push(C),C=lu,F=Ru(),(t=bu())!==B?C=t:(lu=C,C=B);return C=Ru(),F=lu,pu++,u.length>lu?(t=u.charAt(lu),lu++):(t=B,0===pu&&$u(P)),pu--,t===B?F=void 0:(lu=F,F=B),F!==B?A=E:(lu=A,A=B),du[r]={nextPos:lu,result:A},A}function bu(){var A,E,C,F,t,r=32*lu+1,e=du[r];return e?(lu=e.nextPos,e.result):(A=lu,(E=wu())!==B?(Ru(),61===u.charCodeAt(lu)?(C="=",lu++):(C=B,0===pu&&$u(g)),C!==B?(Ru(),(F=ju())!==B?(Ru(),iu=A,t=F,A=Uu({names:E.names,values:t})):(lu=A,A=B)):(lu=A,A=B)):(lu=A,A=B),du[r]={nextPos:lu,result:A},A)}function wu(){var A,E,C,F,t,r,e,D=32*lu+2,n=du[D];if(n)return lu=n.nextPos,n.result;if(A=lu,(E=Lu())!==B){for(C=[],F=lu,_u(),46===u.charCodeAt(lu)?(t=".",lu++):(t=B,0===pu&&$u(v)),t!==B?(_u(),(r=Lu())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);F!==B;)C.push(F),F=lu,_u(),46===u.charCodeAt(lu)?(t=".",lu++):(t=B,0===pu&&$u(v)),t!==B?(_u(),(r=Lu())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);iu=A,e=C,A=Uu({type:"QualifiedName",names:[E,...e]})}else lu=A,A=B;return du[D]={nextPos:lu,result:A},A}function ju(){var A,E,C,F,t,r,e,D=32*lu+3,n=du[D];if(n)return lu=n.nextPos,n.result;if(A=lu,(E=Ou())!==B){for(C=[],F=lu,_u(),59===u.charCodeAt(lu)?(t=";",lu++):(t=B,0===pu&&$u(y)),t!==B?(_u(),(r=Ou())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);F!==B;)C.push(F),F=lu,_u(),59===u.charCodeAt(lu)?(t=";",lu++):(t=B,0===pu&&$u(y)),t!==B?(_u(),(r=Ou())!==B?F=r:(lu=F,F=B)):(lu=F,F=B);iu=A,e=C,A=[E,...e]}else lu=A,A=B;return du[D]={nextPos:lu,result:A},A}function Ou(){var A,E,C,F,t=32*lu+4,r=du[t];return r?(lu=r.nextPos,r.result):(A=lu,"$("===u.substr(lu,2)?(E="$(",lu+=2):(E=B,0===pu&&$u(m)),E!==B&&(C=wu())!==B?(41===u.charCodeAt(lu)?(F=")",lu++):(F=B,0===pu&&$u($)),F!==B?A=C:(lu=A,A=B)):(lu=A,A=B),A===B&&(A=function(){var u,A,E,C,F,t=32*lu+5,r=du[t];if(r)return lu=r.nextPos,r.result;if(pu++,u=lu,(A=Zu())!==B){for(E=[],C=lu,_u(),(F=Zu())!==B?C=F:(lu=C,C=B);C!==B;)E.push(C),C=lu,_u(),(F=Zu())!==B?C=F:(lu=C,C=B);iu=u,u=Uu({type:"Literal",value:A+E.join("")})}else lu=u,u=B;return pu--,u===B&&(A=B,0===pu&&$u(S)),du[t]={nextPos:lu,result:u},u}(),A===B&&(A=function(){var A,E,C,F,t,r,e,D,n,o,s=32*lu+6,a=du[s];if(a)return lu=a.nextPos,a.result;if(pu++,A=lu,34===u.charCodeAt(lu)?(E='"',lu++):(E=B,0===pu&&$u(w)),E!==B){if(C=lu,F=lu,t=[],(r=Zu())!==B)for(;r!==B;)t.push(r),r=Zu();else t=B;if(t!==B){if(r=[],e=lu,D=[],(n=qu())!==B)for(;n!==B;)D.push(n),n=qu();else D=B;if(D!==B){if(n=[],(o=Zu())!==B)for(;o!==B;)n.push(o),o=Zu();else n=B;n!==B?e=D=[D,n]:(lu=e,e=B)}else lu=e,e=B;for(;e!==B;){if(r.push(e),e=lu,D=[],(n=qu())!==B)for(;n!==B;)D.push(n),n=qu();else D=B;if(D!==B){if(n=[],(o=Zu())!==B)for(;o!==B;)n.push(o),o=Zu();else n=B;n!==B?e=D=[D,n]:(lu=e,e=B)}else lu=e,e=B}for(e=[],D=qu();D!==B;)e.push(D),D=qu();F=t=[t,r,e]}else lu=F,F=B;(C=F!==B?u.substring(C,lu):F)!==B?(34===u.charCodeAt(lu)?(F='"',lu++):(F=B,0===pu&&$u(w)),F!==B?(iu=A,A=Uu({type:"Literal",value:C})):(lu=A,A=B)):(lu=A,A=B)}else lu=A,A=B;return pu--,A===B&&(E=B,0===pu&&$u(b)),du[s]={nextPos:lu,result:A},A}(),A===B&&(A=function(){var A,E,C,F,t=32*lu+7,r=du[t];return r?(lu=r.nextPos,r.result):(A=lu,91===u.charCodeAt(lu)?(E="[",lu++):(E=B,0===pu&&$u(j)),E!==B&&(C=ju())!==B?(93===u.charCodeAt(lu)?(F="]",lu++):(F=B,0===pu&&$u(O)),F!==B?(iu=A,A=Uu({type:"SubList",values:C})):(lu=A,A=B)):(lu=A,A=B),du[t]={nextPos:lu,result:A},A)}()))),du[t]={nextPos:lu,result:A},A)}function Ru(){var u,A,E=32*lu+8,C=du[E];if(C)return lu=C.nextPos,C.result;for(u=[],(A=qu())===B&&(A=Nu())===B&&(A=Qu());A!==B;)u.push(A),(A=qu())===B&&(A=Nu())===B&&(A=Qu());return du[E]={nextPos:lu,result:u},u}function _u(){var A,E,C,F,t=32*lu+9,r=du[t];if(r)return lu=r.nextPos,r.result;for(A=[],32===u.charCodeAt(lu)?(E=" ",lu++):(E=B,0===pu&&$u(R)),E===B&&(9===u.charCodeAt(lu)?(E="\t",lu++):(E=B,0===pu&&$u(_)),E===B&&(E=lu,92===u.charCodeAt(lu)?(C="\\",lu++):(C=B,0===pu&&$u(L)),C!==B&&(F=Nu())!==B?E=C=[C,F]:(lu=E,E=B),E===B&&(E=Qu())));E!==B;)A.push(E),32===u.charCodeAt(lu)?(E=" ",lu++):(E=B,0===pu&&$u(R)),E===B&&(9===u.charCodeAt(lu)?(E="\t",lu++):(E=B,0===pu&&$u(_)),E===B&&(E=lu,92===u.charCodeAt(lu)?(C="\\",lu++):(C=B,0===pu&&$u(L)),C!==B&&(F=Nu())!==B?E=C=[C,F]:(lu=E,E=B),E===B&&(E=Qu())));return du[t]={nextPos:lu,result:A},A}function Lu(){var u,A,E,C,F=32*lu+10,t=du[F];if(t)return lu=t.nextPos,t.result;if(pu++,u=lu,(A=zu())!==B){for(E=[],C=Mu();C!==B;)E.push(C),C=Mu();iu=u,u=A+E.join("")}else lu=u,u=B;return pu--,u===B&&(A=B,0===pu&&$u(z)),du[F]={nextPos:lu,result:u},u}function zu(){var A,E=32*lu+11,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+14,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+25,C=du[E];return C?(lu=C.nextPos,C.result):(l.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(eu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+21,C=du[E];return C?(lu=C.nextPos,C.result):(o.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Fu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+24,C=du[E];return C?(lu=C.nextPos,C.result):(c.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(ru)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+22,C=du[E];return C?(lu=C.nextPos,C.result):(s.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(tu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+23,C=du[E];return C?(lu=C.nextPos,C.result):(a.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Bu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+29,C=du[E];return C?(lu=C.nextPos,C.result):(x.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(su)),du[E]={nextPos:lu,result:A},A)}()))))),du[E]={nextPos:lu,result:A},A)}(),A===B&&(95===u.charCodeAt(lu)?(A="_",lu++):(A=B,0===pu&&$u(M))),du[E]={nextPos:lu,result:A},A)}function Mu(){var A,E=32*lu+12,C=du[E];return C?(lu=C.nextPos,C.result):((A=zu())===B&&(A=function(){var A,E=32*lu+15,C=du[E];return C?(lu=C.nextPos,C.result):(A=function(){var A,E=32*lu+27,C=du[E];return C?(lu=C.nextPos,C.result):(f.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(nu)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+26,C=du[E];return C?(lu=C.nextPos,C.result):(i.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(Du)),du[E]={nextPos:lu,result:A},A)}()),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+28,C=du[E];return C?(lu=C.nextPos,C.result):(h.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(ou)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(A=function(){var A,E=32*lu+30,C=du[E];return C?(lu=C.nextPos,C.result):(p.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(au)),du[E]={nextPos:lu,result:A},A)}(),A===B&&(36===u.charCodeAt(lu)?(A="$",lu++):(A=B,0===pu&&$u(Z)),A===B&&(45===u.charCodeAt(lu)?(A="-",lu++):(A=B,0===pu&&$u(k)),A===B&&(8204===u.charCodeAt(lu)?(A="‌",lu++):(A=B,0===pu&&$u(q)),A===B&&(8205===u.charCodeAt(lu)?(A="‍",lu++):(A=B,0===pu&&$u(J))))))))),du[E]={nextPos:lu,result:A},A)}function Zu(){var A,E,C=32*lu+13,F=du[C];return F?(lu=F.nextPos,F.result):((A=Mu())===B&&(46===u.charCodeAt(lu)?(A=".",lu++):(A=B,0===pu&&$u(v)),A===B&&(47===u.charCodeAt(lu)?(A="/",lu++):(A=B,0===pu&&$u(N)),A===B&&(42===u.charCodeAt(lu)?(A="*",lu++):(A=B,0===pu&&$u(Q)),A===B&&(A=lu,92===u.charCodeAt(lu)?(E="\\",lu++):(E=B,0===pu&&$u(L)),E!==B&&(iu=A,E="/"),A=E)))),du[C]={nextPos:lu,result:A},A)}function ku(){var A,E=32*lu+16,C=du[E];return C?(lu=C.nextPos,C.result):(u.length>lu?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(P)),du[E]={nextPos:lu,result:A},A)}function qu(){var A,E=32*lu+17,C=du[E];return C?(lu=C.nextPos,C.result):(pu++,9===u.charCodeAt(lu)?(A="\t",lu++):(A=B,0===pu&&$u(_)),A===B&&(11===u.charCodeAt(lu)?(A="\v",lu++):(A=B,0===pu&&$u(G)),A===B&&(12===u.charCodeAt(lu)?(A="\f",lu++):(A=B,0===pu&&$u(H)),A===B&&(32===u.charCodeAt(lu)?(A=" ",lu++):(A=B,0===pu&&$u(R)),A===B&&(160===u.charCodeAt(lu)?(A=" ",lu++):(A=B,0===pu&&$u(I)),A===B&&(65279===u.charCodeAt(lu)?(A="\ufeff",lu++):(A=B,0===pu&&$u(K)),A===B&&(A=function(){var A,E=32*lu+31,C=du[E];return C?(lu=C.nextPos,C.result):(d.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(cu)),du[E]={nextPos:lu,result:A},A)}())))))),pu--,A===B&&0===pu&&$u(U),du[E]={nextPos:lu,result:A},A)}function Ju(){var A,E=32*lu+18,C=du[E];return C?(lu=C.nextPos,C.result):(n.test(u.charAt(lu))?(A=u.charAt(lu),lu++):(A=B,0===pu&&$u(T)),du[E]={nextPos:lu,result:A},A)}function Nu(){var A,E=32*lu+19,C=du[E];return C?(lu=C.nextPos,C.result):(pu++,10===u.charCodeAt(lu)?(A="\n",lu++):(A=B,0===pu&&$u(W)),A===B&&("\r\n"===u.substr(lu,2)?(A="\r\n",lu+=2):(A=B,0===pu&&$u(X)),A===B&&(13===u.charCodeAt(lu)?(A="\r",lu++):(A=B,0===pu&&$u(Y)),A===B&&(8232===u.charCodeAt(lu)?(A="\u2028",lu++):(A=B,0===pu&&$u(uu)),A===B&&(8233===u.charCodeAt(lu)?(A="\u2029",lu++):(A=B,0===pu&&$u(Au)))))),pu--,A===B&&0===pu&&$u(V),du[E]={nextPos:lu,result:A},A)}function Qu(){var A,E,C,F,t,r,e=32*lu+20,D=du[e];if(D)return lu=D.nextPos,D.result;if(pu++,A=lu,35===u.charCodeAt(lu)?(E="#",lu++):(E=B,0===pu&&$u(Cu)),E!==B){for(C=[],F=lu,t=lu,pu++,r=Ju(),pu--,r===B?t=void 0:(lu=t,t=B),t!==B&&(r=ku())!==B?F=t=[t,r]:(lu=F,F=B);F!==B;)C.push(F),F=lu,t=lu,pu++,r=Ju(),pu--,r===B?t=void 0:(lu=t,t=B),t!==B&&(r=ku())!==B?F=t=[t,r]:(lu=F,F=B);A=E=[E,C]}else lu=A,A=B;return pu--,A===B&&(E=B,0===pu&&$u(Eu)),du[e]={nextPos:lu,result:A},A}function Uu(u){return{...u,source:mu(iu,lu).source}}if((E=D())!==B&&lu===u.length)return E;throw E!==B&&lu<u.length&&$u({type:"end"}),C=xu,F=hu<u.length?u.charAt(hu):null,t=hu<u.length?mu(hu,hu+1):mu(hu,hu),new peg$SyntaxError(peg$SyntaxError.buildMessage(C,F),C,F,t)}peg$subclass(peg$SyntaxError,Error),peg$SyntaxError.prototype.format=function(u){var A="Error: "+this.message;if(this.location){var E,C=null;for(E=0;E<u.length;E++)if(u[E].source===this.location.source){C=u[E].text.split(/\r\n|\n|\r/g);break}var F=this.location.start,t=this.location.source+":"+F.line+":"+F.column;if(C){var B=this.location.end,r=peg$padEnd("",F.line.toString().length),e=C[F.line-1],D=F.line===B.line?B.column:e.length+1;A+="\n --\x3e "+t+"\n"+r+" |\n"+F.line+" | "+e+"\n"+r+" | "+peg$padEnd("",F.column-1)+peg$padEnd("",D-F.column,"^")}else A+="\n at "+t}return A},peg$SyntaxError.buildMessage=function(u,A){var E={literal:function(u){return'"'+F(u.text)+'"'},class:function(u){var A=u.parts.map((function(u){return Array.isArray(u)?t(u[0])+"-"+t(u[1]):t(u)}));return"["+(u.inverted?"^":"")+A+"]"},any:function(){return"any character"},end:function(){return"end of input"},other:function(u){return u.description}};function C(u){return u.charCodeAt(0).toString(16).toUpperCase()}function F(u){return u.replace(/\\/g,"\\\\").replace(/"/g,'\\"').replace(/\0/g,"\\0").replace(/\t/g,"\\t").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/[\x00-\x0F]/g,(function(u){return"\\x0"+C(u)})).replace(/[\x10-\x1F\x7F-\x9F]/g,(function(u){return"\\x"+C(u)}))}function t(u){return u.replace(/\\/g,"\\\\").replace(/\]/g,"\\]").replace(/\^/g,"\\^").replace(/-/g,"\\-").replace(/\0/g,"\\0").replace(/\t/g,"\\t").replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/[\x00-\x0F]/g,(function(u){return"\\x0"+C(u)})).replace(/[\x10-\x1F\x7F-\x9F]/g,(function(u){return"\\x"+C(u)}))}function B(u){return E[u.type](u)}return"Expected "+function(u){var A,E,C=u.map(B);if(C.sort(),C.length>0){for(A=1,E=1;A<C.length;A++)C[A-1]!==C[A]&&(C[E]=C[A],E++);C.length=E}switch(C.length){case 1:return C[0];case 2:return C[0]+" or "+C[1];default:return C.slice(0,-1).join(", ")+", or "+C[C.length-1]}}(u)+" but "+function(u){return u?'"'+F(u)+'"':"end of input"}(A)+" found."};
 ;// CONCATENATED MODULE: ./src/manifest.js
 
 
@@ -7283,30 +9920,49 @@ async function writeManifest(filename, xml) {
   return promises_namespaceObject.writeFile(filename, text);
 }
 
-function manifestProducts(manifest) {
-  const app =
-    manifest["iq:manifest"]["iq:application"] ||
-    manifest["iq:manifest"]["iq:barrel"];
-  return app[0]["iq:products"][0]["iq:product"]
-    .map((p) => p["$"]["id"])
-    .sort()
-    .filter((p, i, a) => !i || p !== a[i - 1]);
+function manifestProducts(manifest) {
+  const app =
+    manifest["iq:manifest"]["iq:application"] ||
+    manifest["iq:manifest"]["iq:barrel"];
+  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"];
 }
 
-async function getDeviceInfo() {
-  const files = await (0,external_util_cjs_namespaceObject.globa)(`${external_util_cjs_namespaceObject.connectiq}/Devices/*/compiler.json`);
-  return Promise.all(
-    files.map((file) => {
-      return promises_namespaceObject.readFile(file).then((data) => {
-        const { deviceId, appTypes, deviceFamily } = JSON.parse(
-          data.toString()
-        );
-        return [deviceId, { appTypes, deviceFamily }];
-      });
-    })
-  ).then((info) => {
-    return Object.fromEntries(info);
-  });
+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) {
@@ -7320,13 +9976,19 @@ async function checkManifest(manifest, products) {
   if (!app) return ok;
 
   const elm = app[0];
-  const type = elm.$.type.replace(/-/, "").toLowerCase();
-  const deviceInfo = await getDeviceInfo();
+  const id = elm.$.id;
+  if (id.length < 32 || !/^[-_0-9a-f.]+$/.test(id)) {
+    ok = false;
+    elm.$.id = "08070f9d-8b4e-40a4-9c49-fe67a2a55dec";
+  }
+  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 (
@@ -7365,6 +10027,56 @@ async function checkManifest(manifest, products) {
 
 
 
+
+
+
+
+async function default_jungle() {
+  const assignments = [];
+  const devices = await (0,external_sdk_util_cjs_namespaceObject.getDeviceInfo)();
+  const languages = await (0,external_sdk_util_cjs_namespaceObject.getLanguages)();
+  const literal = (value) => ({ type: "Literal", value });
+  const qname = (name) => ({ type: "QualifiedName", names: name.split(".") });
+  const assign = (name, values) =>
+    assignments.push({ names: name.split("."), values });
+  const rassign = (name, values, base) => {
+    assign(name, base ? [qname(name)].concat(values) : values);
+  };
+  const rezAndLang = (id, rez, base) => {
+    if (base) {
+      assign(id, [qname(base)]);
+    }
+    rassign(`${id}.resourcePath`, [literal(rez)], base);
+
+    languages.forEach((l) =>
+      rassign(`${id}.lang.${l.id}`, [literal(`${rez}-${l.id}`)], base)
+    );
+  };
+  const done = {};
+
+  assign("base.sourcePath", [literal("./**.mc")]);
+  rezAndLang("base", "resources");
+  Object.entries(devices).forEach(([deviceId, { deviceFamily }]) => {
+    const match = deviceFamily.match(/^(\w+)-\d+x\d+/);
+    if (!match) {
+      throw new Error(
+        `Strange deviceFamily (${deviceFamily}) for device ${deviceId}`
+      );
+    }
+    const shape = match[1];
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(done, shape)) {
+      rezAndLang(shape, `resources-${shape}`, "base");
+      done[shape] = true;
+    }
+    if (!(0,external_api_cjs_namespaceObject.hasProperty)(done, deviceFamily)) {
+      rezAndLang(deviceFamily, `resources-${deviceFamily}`, shape);
+      done[deviceFamily] = true;
+    }
+    rezAndLang(deviceId, `resources-${deviceId}`, deviceFamily);
+  });
+  return process_assignments(assignments, {});
+}
+
 function process_assignments(assignments, current) {
   return assignments.reduce((state, a) => {
     const { node, dot, dotnames } = a.names.reduce(
@@ -7382,30 +10094,30 @@ function process_assignments(assignments, current) {
     );
     // an assignment to a node overwrites its old value
     Object.keys(node).forEach((k) => delete node[k]);
-    if (dot) {
-      const process_list = (values) => {
-        for (let i = values.length; i--; ) {
-          const v = values[i];
-          if (
-            v.type == "QualifiedName" &&
-            v.names.every((n, i) => n === a.names[i])
-          ) {
-            a.values.splice(
-              i,
-              1,
-              ...dot.map((v) =>
-                v.type == "QualifiedName"
-                  ? { ...v, names: v.names.concat(dotnames) }
-                  : v
-              )
-            );
-          } else if (v.type == "SubList") {
-            process_list(v.values);
-          }
+    const process_list = (values) => {
+      for (let i = values.length; i--; ) {
+        const v = values[i];
+        if (
+          v.type == "QualifiedName" &&
+          v.names.every((n, i) => n === a.names[i])
+        ) {
+          values.splice(
+            i,
+            1,
+            ...(dot
+              ? dot.map((v) =>
+                  v.type == "QualifiedName"
+                    ? { ...v, names: v.names.concat(dotnames) }
+                    : v
+                )
+              : [])
+          );
+        } else if (v.type == "SubList") {
+          process_list(v.values);
         }
-      };
-      process_list(a.values);
-    }
+      }
+    };
+    process_list(a.values);
     if (
       a.names.length === 1 &&
       a.values.length === 1 &&
@@ -7472,14 +10184,11 @@ async function parse_one(file) {
 // return a jungle object with all local variables resolved,
 // but all qualifier references left unresolved.
 async function process_jungles(sources) {
-  const sdk = await (0,external_util_cjs_namespaceObject.getSdkPath)();
-
   if (!Array.isArray(sources)) {
     sources = [sources];
   }
-  const all = [[`${sdk}bin/default.jungle`, null], ...sources];
-  const results = await Promise.all(all.map(parse_one));
-  const state = {};
+  const results = await Promise.all(sources.map(parse_one));
+  const state = await default_jungle();
   results.forEach((r) => process_assignments(r, state));
   return state;
 }
@@ -7569,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) {
@@ -7579,12 +10288,15 @@ async function resolve_literals(qualifier, default_source) {
     (
       await Promise.all(
         literals.map(async (v) => {
+          if (v.type == "SubList") {
+            return resolve_file_list(v.values);
+          }
           let resolved = resolve_filename(v, default_source);
           if (/[*?\[\]\{\}]/.test(resolved)) {
             // Jungle files can contain "./**.mc" which is supposed to match
             // any mc file under "./". The standard way to express that
             // is "./**/*.mc", which is what glob expects, so translate.
-            resolved = resolved.replace(/\/\*\*([^/])/g, "/**/*$1");
+            resolved = resolved.replace(/[\\\/]\*\*([^\\\/])/g, "/**/*$1");
             const match = await (0,external_util_cjs_namespaceObject.globa)(resolved);
             return match.length ? resolved : null;
           } else {
@@ -7624,7 +10336,101 @@ 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_.dirname(file);
+    const sourceExcludes = rez.build.exclude
+      .map((e) => e.$.file)
+      .filter((f) => f != null)
+      .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_.join(dir, f, "**", "*.mc").replace(/\\/g, "/"));
+    if (filePatterns.length) {
+      const files = (
+        await Promise.all(filePatterns.map((p) => (0,external_util_cjs_namespaceObject.globa)(p)))
+      ).flat();
+      sourceExcludes.push(...files);
+    }
+    const excludeAnnotations = rez.build.exclude
+      .map((e) => e.$.annotation)
+      .filter((f) => f != null);
+    return { sourceExcludes, excludeAnnotations };
+  }
+}
+async function find_build_instructions(targets) {
+  const resourceGroups = {};
+  await Promise.all(
+    targets.map(async (p) => {
+      if (!p.qualifier.resourcePath) return;
+      const key = p.qualifier.resourcePath.join(";");
+      if (!(0,external_api_cjs_namespaceObject.hasProperty)(resourceGroups, key)) {
+        resourceGroups[key] = {
+          resourcePath: p.qualifier.resourcePath,
+          products: [],
+        };
+        const paths = (
+          await Promise.all(
+            p.qualifier.resourcePath.map((pattern) =>
+              (0,external_util_cjs_namespaceObject.globa)(pattern, { mark: true })
+            )
+          )
+        ).flat();
+
+        const sourceExcludes = [];
+        const excludeAnnotations = [];
+        const resourceFiles = await Promise.all(
+          paths.map((path) =>
+            path.endsWith("/") ? (0,external_util_cjs_namespaceObject.globa)(`${path}**/*.xml`, { mark: true }) : path
+          )
+        );
+        const buildInstructions = await Promise.all(
+          resourceFiles
+            .flat()
+            .filter((file) => !file.endsWith("/"))
+            .map((file) => find_build_instructions_in_resource(file))
+        );
+        buildInstructions
+          .filter((i) => i != null)
+          .map((i) => {
+            if (i.sourceExcludes) sourceExcludes.push(...i.sourceExcludes);
+            if (i.excludeAnnotations)
+              excludeAnnotations.push(...i.excludeAnnotations);
+          });
+        if (sourceExcludes.length) {
+          p.qualifier.sourceExcludes = sourceExcludes;
+        }
+        if (excludeAnnotations.length) {
+          if (p.qualifier.excludeAnnotations) {
+            p.qualifier.excludeAnnotations.push(excludeAnnotations);
+          } else {
+            p.qualifier.excludeAnnotations = excludeAnnotations;
+          }
+        }
+      }
+      resourceGroups[key].products.push(p.product);
+    })
+  );
 }
 
 function identify_optimizer_groups(targets, options) {
@@ -7679,17 +10485,25 @@ function identify_optimizer_groups(targets, options) {
     : null;
 
   targets.forEach((target) => {
-    let { sourcePath, barrelPath, excludeAnnotations, annotations } =
-      target.qualifier;
+    let {
+      sourcePath,
+      sourceExcludes,
+      barrelPath,
+      barrelMap,
+      excludeAnnotations,
+      annotations,
+    } = target.qualifier;
     if (excludeAnnotations && ignoredExcludeAnnotations) {
       excludeAnnotations = getStrsWithIgnore(
         excludeAnnotations,
         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]))
@@ -7699,7 +10513,9 @@ function identify_optimizer_groups(targets, options) {
     }
     const optimizerConfig = {
       sourcePath,
+      sourceExcludes,
       barrelPath,
+      barrelMap,
       excludeAnnotations,
       annotations,
     };
@@ -7719,42 +10535,298 @@ 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));
-  const data = await process_jungles(jungles);
+    .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
-  data["square_watch"] = data["rectangle_watch"];
+  state["square_watch"] = state["rectangle_watch"];
   const manifest_node = resolve_node(
-    data,
-    resolve_node_by_path(data, ["project", "manifest"])
+    state,
+    resolve_node_by_path(state, ["project", "manifest"])
   );
   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(data, data[product]);
+    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) => {
-    if ((0,external_api_cjs_namespaceObject.hasProperty)(data, product) && data[product].products) {
+  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.
-      data[product].products.forEach((p) => add_one(p, product));
+      state[product].products.forEach((p) => add_one(p, product));
     } else {
       add_one(product);
     }
   });
   await promise;
-  identify_optimizer_groups(targets, options);
-  return { manifest, targets, xml };
+  await find_build_instructions(targets);
+  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"
@@ -7764,15 +10836,24 @@ const external_child_process_namespaceObject = require("child_process");
 
 
 
+
 function launchSimulator() {
-  return (0,external_util_cjs_namespaceObject.getSdkPath)().then((sdk) => {
+  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_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
@@ -7829,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: [],
@@ -7842,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;
         }
@@ -7889,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;
 
@@ -8128,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];
@@ -8190,6 +11271,7 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
         (sc.superClass && checkInherited(sc, name))
     );
 
+  state.localsStack = [{}];
   state.exposed = {};
   state.calledFunctions = {};
   state.pre = (node) => {
@@ -8239,8 +11321,74 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
 
       case "EnumDeclaration":
         return false;
-      case "VariableDeclarator":
+      case "ForStatement": {
+        const map = state.localsStack.slice(-1).pop().map;
+        if (map) {
+          state.localsStack.push({ node, map: { ...map } });
+        }
+        break;
+      }
+      case "VariableDeclarator": {
+        const locals = state.localsStack.slice(-1).pop();
+        const { map } = locals;
+        if (map) {
+          if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.id.name)) {
+            // We already have a variable with this name in scope
+            // Recent monkeyc compilers complain, so rename it
+            let suffix = 0;
+            let node_name = node.id.name;
+            const match = node_name.match(/^pmcr_(.*)_(\d+)$/);
+            if (match) {
+              node_name = match[1];
+              suffix = parseInt(match[2], 10) + 1;
+            }
+            if (!locals.inners) {
+              // find all the names declared in this scope, to avoid
+              // more conflicts
+              locals.inners = {};
+              (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
+                if (node.type === "VariableDeclarator") {
+                  locals.inners[node.id.name] = true;
+                }
+              });
+            }
+            let name;
+            while (true) {
+              name = `pmcr_${node_name}_${suffix}`;
+              if (
+                !(0,external_api_cjs_namespaceObject.hasProperty)(map, name) &&
+                !(0,external_api_cjs_namespaceObject.hasProperty)(locals.inners, name)
+              ) {
+                // we also need to ensure that we don't hide the name of
+                // an outer module, class, function, enum or variable,
+                // since someone might want to access it from this scope.
+                let ok = false;
+                let i;
+                for (i = state.stack.length; i--; ) {
+                  const elm = state.stack[i];
+                  if (ok) {
+                    if ((0,external_api_cjs_namespaceObject.hasProperty)(elm.decls, name)) {
+                      break;
+                    }
+                  } else if (elm.node.type === "FunctionDeclaration") {
+                    ok = true;
+                  }
+                }
+                if (i < 0) {
+                  break;
+                }
+              }
+              suffix++;
+            }
+            map[node.id.name] = name;
+            map[name] = true;
+            node.id.name = name;
+          } else {
+            map[node.id.name] = true;
+          }
+        }
         return ["init"];
+      }
       case "UnaryExpression":
         if (node.operator == ":") {
           // If we produce a Symbol, for a given name,
@@ -8255,6 +11403,15 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
         }
         break;
       case "Identifier": {
+        const map = state.localsStack.slice(-1).pop().map;
+        if (map) {
+          if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
+            const name = map[node.name];
+            if (name !== true) {
+              node.name = name;
+            }
+          }
+        }
         if ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, node.name)) {
           if (!lookupAndReplace(node)) {
             state.exposed[node.name] = true;
@@ -8275,7 +11432,20 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
           return ["object"];
         }
         break;
+      case "BlockStatement": {
+        const map = state.localsStack.slice(-1).pop().map;
+        if (map) {
+          state.localsStack.push({
+            node,
+            map: { ...map },
+          });
+        }
+        break;
+      }
       case "FunctionDeclaration": {
+        const map = {};
+        node.params && node.params.forEach((p) => (map[p.name] = true));
+        state.localsStack.push({ node, map });
         const [parent] = state.stack.slice(-2);
         if (parent.type == "ClassDeclaration" && !maybeCalled(node)) {
           let used = false;
@@ -8295,6 +11465,9 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
     }
   };
   state.post = (node) => {
+    if (state.localsStack.slice(-1).pop().node === node) {
+      state.localsStack.pop();
+    }
     const opt = optimizeNode(node);
     if (opt) {
       replace(node, opt);
@@ -8443,6 +11616,15 @@ async function optimizeMonkeyC(fileNames, buildConfig) {
 
 
 
+
+
+function relative_path_no_dotdot(relative) {
+  return relative.replace(
+    /^(\.\.[\\\/])+/,
+    (str) => `__${"dot".repeat(str.length / 3)}__${str.slice(-1)}`
+  );
+}
+
 async function getVSCodeSettings(path) {
   try {
     const settings = await promises_namespaceObject.readFile(path);
@@ -8470,7 +11652,7 @@ async function getConfig(options) {
     if (config[key]) return;
     if (!promise) {
       promise = Promise.resolve()
-        .then(() => getVSCodeSettings(`${external_util_cjs_namespaceObject.appSupport}/Code/User/settings.json`))
+        .then(() => getVSCodeSettings(`${external_sdk_util_cjs_namespaceObject.appSupport}/Code/User/settings.json`))
         .then((globals) =>
           getVSCodeSettings(`${config.workspace}/.vscode/settings.json`).then(
             (locals) => ({ ...globals, ...locals })
@@ -8502,49 +11684,160 @@ 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 { manifest, targets, xml } = await get_jungle(
+  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;
+  if (config.skipOptimization) {
+    if (pick_one >= 0) {
+      options.products = [...options.products];
+      options.products[pick_one] = targets[0].product;
+    }
+    return {
+      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 = p.group.key + (config.releaseBuild ? "-release" : "-debug");
+    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 ||
-      !config.products ||
-      config.products.includes(p.product) ||
-      (p.shape && config.products.includes(p.shape))
+      !options.products ||
+      options.products.includes(p.product) ||
+      (p.shape && options.products.includes(p.shape))
     ) {
       if (pick_one >= 0) {
-        config.products[pick_one] = p.product;
+        // don't modify the original array since it may be shared
+        // (and *is* shared when we're called from test.js)
+        options.products = [...options.products];
+        options.products[pick_one] = p.product;
         pick_one = -1;
       }
       if (!buildConfigs[key]) {
@@ -8557,25 +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 = await checkManifest(
-    xml,
-    targets.map((t) => t.product)
-  );
+  const manifestOk =
+    (!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());
@@ -8583,58 +11880,101 @@ 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";
   }
 
   const parts = [`project.manifest=${relative_manifest}`];
-  const process_field = (prefix, base, name, map) =>
-    base[name] &&
-    parts.push(
-      `${prefix}${name} = ${base[name]
-        .map((s) => (map ? map(s) : s))
-        .join(";")}`
-    );
+  const process_field = (prefix, base, name, mapper) => {
+    if (!base[name]) return;
+    const map_one = (s) => (mapper ? mapper(s) : s);
+    const map = (s) =>
+      Array.isArray(s) ? `[${s.map(map_one).join(";")}]` : map_one(s);
+    parts.push(`${prefix}${name} = ${base[name].map(map).join(";")}`);
+  };
   targets.forEach((jungle) => {
+    if (!buildConfigs[configKey(jungle)]) return;
     const { product, qualifier, group } = jungle;
     const prefix = `${product}.`;
     process_field(prefix, qualifier, "sourcePath", (s) =>
-      external_path_namespaceObject.join(group.dir, external_path_namespaceObject.relative(workspace, s))
-        .replace(/(\/\*\*)\/\*/g, "$1")
+      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.entries(qualifier.lang).forEach(([key, value]) => {
-        process_field(`${prefix}lang.`, value, key, relative_path);
+      Object.keys(qualifier.lang).forEach((key) => {
+        process_field(`${prefix}lang.`, qualifier.lang, key, relative_path);
       });
     }
   });
 
-  const jungleFiles = external_path_namespaceObject.join(
+  const jungleFiles = external_path_.join(
     jungle_dir,
     `${config.releaseBuild ? "release" : "debug"}.jungle`
   );
   promises.push(promises_namespaceObject.writeFile(jungleFiles, parts.join("\n")));
 
   await Promise.all(promises);
-  return { jungleFiles, program: external_path_namespaceObject.basename(external_path_namespaceObject.dirname(manifest)) };
+  return {
+    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) =>
@@ -8653,27 +11993,128 @@ async function generateOneConfig(config) {
     )
   )
     .flat()
-    .filter((file) => !file.endsWith("/"))
-    .map((file) => external_path_namespaceObject.relative(workspace, file))
-    .filter((file) => !file.startsWith("bin"));
+    .filter(
+      (file) =>
+        file.endsWith(".mc") &&
+        !external_path_.relative(workspace, file).startsWith("bin") &&
+        (!buildConfig.sourceExcludes ||
+          !buildConfig.sourceExcludes.includes(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;
+}
 
-  const fnMap = Object.fromEntries(
-    files
-      .filter((src) => /\.mc$/.test(src))
-      .map((file) => [external_path_namespaceObject.join(workspace, file), external_path_namespaceObject.join(output, file)])
+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
   );
 
-  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) return;
+  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_.join(output, "**", "*.mc"), { mark: true })
+  )
+    .filter((file) => !file.endsWith("/"))
+    .sort();
+
+  // check that the set of files thats actually there is the same as the
+  // set of files we're going to generate (in case eg a jungle file change
+  // might have altered it)
+  if (
+    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).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);