@vertexvis/viewer 0.18.1 → 0.18.2-testing.0

package/dist/components/png-decoder.js

@@ -0,0 +1,2405 @@
+/*!
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
+ */
+import { d as __awaiter$2, e as __generator, b as __spreadArray } from './tslib.es6.js';
+import { c as createCommonjsModule } from './_commonjsHelpers.js';
+
+const DefaultErrorSerializer = {
+    deserialize(message) {
+        return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack
+        });
+    },
+    serialize(error) {
+        return {
+            __error_marker: "$$error",
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+        };
+    }
+};
+const isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+const DefaultSerializer = {
+    deserialize(message) {
+        if (isSerializedError(message)) {
+            return DefaultErrorSerializer.deserialize(message);
+        }
+        else {
+            return message;
+        }
+    },
+    serialize(input) {
+        if (input instanceof Error) {
+            return DefaultErrorSerializer.serialize(input);
+        }
+        else {
+            return input;
+        }
+    }
+};
+
+let registeredSerializer = DefaultSerializer;
+function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+    return registeredSerializer.serialize(input);
+}
+
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+let bundleURL;
+function getBundleURLCached() {
+    if (!bundleURL) {
+        bundleURL = getBundleURL();
+    }
+    return bundleURL;
+}
+function getBundleURL() {
+    // Attempt to find the URL of the current script and use that as the base URL
+    try {
+        throw new Error;
+    }
+    catch (err) {
+        const matches = ("" + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^)\n]+/g);
+        if (matches) {
+            return getBaseURL(matches[0]);
+        }
+    }
+    return "/";
+}
+function getBaseURL(url) {
+    return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
+}
+
+// tslint:disable max-classes-per-file
+const defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency
+    ? navigator.hardwareConcurrency
+    : 4;
+const isAbsoluteURL = (value) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value);
+function createSourceBlobURL(code) {
+    const blob = new Blob([code], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+}
+function selectWorkerImplementation() {
+    if (typeof Worker === "undefined") {
+        // Might happen on Safari, for instance
+        // The idea is to only fail if the constructor is actually used
+        return class NoWebWorker {
+            constructor() {
+                throw Error("No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.");
+            }
+        };
+    }
+    class WebWorker extends Worker {
+        constructor(url, options) {
+            var _a, _b;
+            if (typeof url === "string" && options && options._baseURL) {
+                url = new URL(url, options._baseURL);
+            }
+            else if (typeof url === "string" && !isAbsoluteURL(url) && getBundleURLCached().match(/^file:\/\//i)) {
+                url = new URL(url, getBundleURLCached().replace(/\/[^\/]+$/, "/"));
+                if ((_a = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _a !== void 0 ? _a : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            if (typeof url === "string" && isAbsoluteURL(url)) {
+                // Create source code blob loading JS file via `importScripts()`
+                // to circumvent worker CORS restrictions
+                if ((_b = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _b !== void 0 ? _b : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            super(url, options);
+        }
+    }
+    class BlobWorker extends WebWorker {
+        constructor(blob, options) {
+            const url = window.URL.createObjectURL(blob);
+            super(url, options);
+        }
+        static fromText(source, options) {
+            const blob = new window.Blob([source], { type: "text/javascript" });
+            return new BlobWorker(blob, options);
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: WebWorker
+    };
+}
+let implementation;
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+
+/**
+ * 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
+ */
+
+var ms = 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' : '');
+}
+
+/**
+ * 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 = ms;
+	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 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.substr(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;
+}
+
+var common = setup;
+
+var browser = createCommonjsModule(function (module, exports) {
+/* 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 = common(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;
+	}
+};
+});
+
+const hasSymbols = () => typeof Symbol === "function";
+const hasSymbol = (name) => hasSymbols() && Boolean(Symbol[name]);
+const getSymbol = (name) => hasSymbol(name) ? Symbol[name] : "@@" + name;
+if (!hasSymbol("asyncIterator")) {
+    Symbol.asyncIterator = Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator");
+}
+
+/**
+ * Based on <https://raw.githubusercontent.com/zenparsing/zen-observable/master/src/Observable.js>
+ * At commit: f63849a8c60af5d514efc8e9d6138d8273c49ad6
+ */
+const SymbolIterator = getSymbol("iterator");
+const SymbolObservable = getSymbol("observable");
+const SymbolSpecies = getSymbol("species");
+// === Abstract Operations ===
+function getMethod(obj, key) {
+    const value = obj[key];
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value !== "function") {
+        throw new TypeError(value + " is not a function");
+    }
+    return value;
+}
+function getSpecies(obj) {
+    let ctor = obj.constructor;
+    if (ctor !== undefined) {
+        ctor = ctor[SymbolSpecies];
+        if (ctor === null) {
+            ctor = undefined;
+        }
+    }
+    return ctor !== undefined ? ctor : Observable;
+}
+function isObservable(x) {
+    return x instanceof Observable; // SPEC: Brand check
+}
+function hostReportError(error) {
+    if (hostReportError.log) {
+        hostReportError.log(error);
+    }
+    else {
+        setTimeout(() => { throw error; }, 0);
+    }
+}
+function enqueue(fn) {
+    Promise.resolve().then(() => {
+        try {
+            fn();
+        }
+        catch (e) {
+            hostReportError(e);
+        }
+    });
+}
+function cleanupSubscription(subscription) {
+    const cleanup = subscription._cleanup;
+    if (cleanup === undefined) {
+        return;
+    }
+    subscription._cleanup = undefined;
+    if (!cleanup) {
+        return;
+    }
+    try {
+        if (typeof cleanup === "function") {
+            cleanup();
+        }
+        else {
+            const unsubscribe = getMethod(cleanup, "unsubscribe");
+            if (unsubscribe) {
+                unsubscribe.call(cleanup);
+            }
+        }
+    }
+    catch (e) {
+        hostReportError(e);
+    }
+}
+function closeSubscription(subscription) {
+    subscription._observer = undefined;
+    subscription._queue = undefined;
+    subscription._state = "closed";
+}
+function flushSubscription(subscription) {
+    const queue = subscription._queue;
+    if (!queue) {
+        return;
+    }
+    subscription._queue = undefined;
+    subscription._state = "ready";
+    for (const item of queue) {
+        notifySubscription(subscription, item.type, item.value);
+        if (subscription._state === "closed") {
+            break;
+        }
+    }
+}
+function notifySubscription(subscription, type, value) {
+    subscription._state = "running";
+    const observer = subscription._observer;
+    try {
+        const m = observer ? getMethod(observer, type) : undefined;
+        switch (type) {
+            case "next":
+                if (m)
+                    m.call(observer, value);
+                break;
+            case "error":
+                closeSubscription(subscription);
+                if (m)
+                    m.call(observer, value);
+                else
+                    throw value;
+                break;
+            case "complete":
+                closeSubscription(subscription);
+                if (m)
+                    m.call(observer);
+                break;
+        }
+    }
+    catch (e) {
+        hostReportError(e);
+    }
+    if (subscription._state === "closed") {
+        cleanupSubscription(subscription);
+    }
+    else if (subscription._state === "running") {
+        subscription._state = "ready";
+    }
+}
+function onNotify(subscription, type, value) {
+    if (subscription._state === "closed") {
+        return;
+    }
+    if (subscription._state === "buffering") {
+        subscription._queue = subscription._queue || [];
+        subscription._queue.push({ type, value });
+        return;
+    }
+    if (subscription._state !== "ready") {
+        subscription._state = "buffering";
+        subscription._queue = [{ type, value }];
+        enqueue(() => flushSubscription(subscription));
+        return;
+    }
+    notifySubscription(subscription, type, value);
+}
+class Subscription {
+    constructor(observer, subscriber) {
+        // ASSERT: observer is an object
+        // ASSERT: subscriber is callable
+        this._cleanup = undefined;
+        this._observer = observer;
+        this._queue = undefined;
+        this._state = "initializing";
+        const subscriptionObserver = new SubscriptionObserver(this);
+        try {
+            this._cleanup = subscriber.call(undefined, subscriptionObserver);
+        }
+        catch (e) {
+            subscriptionObserver.error(e);
+        }
+        if (this._state === "initializing") {
+            this._state = "ready";
+        }
+    }
+    get closed() {
+        return this._state === "closed";
+    }
+    unsubscribe() {
+        if (this._state !== "closed") {
+            closeSubscription(this);
+            cleanupSubscription(this);
+        }
+    }
+}
+class SubscriptionObserver {
+    constructor(subscription) { this._subscription = subscription; }
+    get closed() { return this._subscription._state === "closed"; }
+    next(value) { onNotify(this._subscription, "next", value); }
+    error(value) { onNotify(this._subscription, "error", value); }
+    complete() { onNotify(this._subscription, "complete"); }
+}
+/**
+ * The basic Observable class. This primitive is used to wrap asynchronous
+ * data streams in a common standardized data type that is interoperable
+ * between libraries and can be composed to represent more complex processes.
+ */
+class Observable {
+    constructor(subscriber) {
+        if (!(this instanceof Observable)) {
+            throw new TypeError("Observable cannot be called as a function");
+        }
+        if (typeof subscriber !== "function") {
+            throw new TypeError("Observable initializer must be a function");
+        }
+        this._subscriber = subscriber;
+    }
+    subscribe(nextOrObserver, onError, onComplete) {
+        if (typeof nextOrObserver !== "object" || nextOrObserver === null) {
+            nextOrObserver = {
+                next: nextOrObserver,
+                error: onError,
+                complete: onComplete
+            };
+        }
+        return new Subscription(nextOrObserver, this._subscriber);
+    }
+    pipe(first, ...mappers) {
+        // tslint:disable-next-line no-this-assignment
+        let intermediate = this;
+        for (const mapper of [first, ...mappers]) {
+            intermediate = mapper(intermediate);
+        }
+        return intermediate;
+    }
+    tap(nextOrObserver, onError, onComplete) {
+        const tapObserver = typeof nextOrObserver !== "object" || nextOrObserver === null
+            ? {
+                next: nextOrObserver,
+                error: onError,
+                complete: onComplete
+            }
+            : nextOrObserver;
+        return new Observable(observer => {
+            return this.subscribe({
+                next(value) {
+                    tapObserver.next && tapObserver.next(value);
+                    observer.next(value);
+                },
+                error(error) {
+                    tapObserver.error && tapObserver.error(error);
+                    observer.error(error);
+                },
+                complete() {
+                    tapObserver.complete && tapObserver.complete();
+                    observer.complete();
+                },
+                start(subscription) {
+                    tapObserver.start && tapObserver.start(subscription);
+                }
+            });
+        });
+    }
+    forEach(fn) {
+        return new Promise((resolve, reject) => {
+            if (typeof fn !== "function") {
+                reject(new TypeError(fn + " is not a function"));
+                return;
+            }
+            function done() {
+                subscription.unsubscribe();
+                resolve(undefined);
+            }
+            const subscription = this.subscribe({
+                next(value) {
+                    try {
+                        fn(value, done);
+                    }
+                    catch (e) {
+                        reject(e);
+                        subscription.unsubscribe();
+                    }
+                },
+                error(error) {
+                    reject(error);
+                },
+                complete() {
+                    resolve(undefined);
+                }
+            });
+        });
+    }
+    map(fn) {
+        if (typeof fn !== "function") {
+            throw new TypeError(fn + " is not a function");
+        }
+        const C = getSpecies(this);
+        return new C(observer => this.subscribe({
+            next(value) {
+                let propagatedValue = value;
+                try {
+                    propagatedValue = fn(value);
+                }
+                catch (e) {
+                    return observer.error(e);
+                }
+                observer.next(propagatedValue);
+            },
+            error(e) { observer.error(e); },
+            complete() { observer.complete(); },
+        }));
+    }
+    filter(fn) {
+        if (typeof fn !== "function") {
+            throw new TypeError(fn + " is not a function");
+        }
+        const C = getSpecies(this);
+        return new C(observer => this.subscribe({
+            next(value) {
+                try {
+                    if (!fn(value))
+                        return;
+                }
+                catch (e) {
+                    return observer.error(e);
+                }
+                observer.next(value);
+            },
+            error(e) { observer.error(e); },
+            complete() { observer.complete(); },
+        }));
+    }
+    reduce(fn, seed) {
+        if (typeof fn !== "function") {
+            throw new TypeError(fn + " is not a function");
+        }
+        const C = getSpecies(this);
+        const hasSeed = arguments.length > 1;
+        let hasValue = false;
+        let acc = seed;
+        return new C(observer => this.subscribe({
+            next(value) {
+                const first = !hasValue;
+                hasValue = true;
+                if (!first || hasSeed) {
+                    try {
+                        acc = fn(acc, value);
+                    }
+                    catch (e) {
+                        return observer.error(e);
+                    }
+                }
+                else {
+                    acc = value;
+                }
+            },
+            error(e) { observer.error(e); },
+            complete() {
+                if (!hasValue && !hasSeed) {
+                    return observer.error(new TypeError("Cannot reduce an empty sequence"));
+                }
+                observer.next(acc);
+                observer.complete();
+            },
+        }));
+    }
+    concat(...sources) {
+        const C = getSpecies(this);
+        return new C(observer => {
+            let subscription;
+            let index = 0;
+            function startNext(next) {
+                subscription = next.subscribe({
+                    next(v) { observer.next(v); },
+                    error(e) { observer.error(e); },
+                    complete() {
+                        if (index === sources.length) {
+                            subscription = undefined;
+                            observer.complete();
+                        }
+                        else {
+                            startNext(C.from(sources[index++]));
+                        }
+                    },
+                });
+            }
+            startNext(this);
+            return () => {
+                if (subscription) {
+                    subscription.unsubscribe();
+                    subscription = undefined;
+                }
+            };
+        });
+    }
+    flatMap(fn) {
+        if (typeof fn !== "function") {
+            throw new TypeError(fn + " is not a function");
+        }
+        const C = getSpecies(this);
+        return new C(observer => {
+            const subscriptions = [];
+            const outer = this.subscribe({
+                next(value) {
+                    let normalizedValue;
+                    if (fn) {
+                        try {
+                            normalizedValue = fn(value);
+                        }
+                        catch (e) {
+                            return observer.error(e);
+                        }
+                    }
+                    else {
+                        normalizedValue = value;
+                    }
+                    const inner = C.from(normalizedValue).subscribe({
+                        next(innerValue) { observer.next(innerValue); },
+                        error(e) { observer.error(e); },
+                        complete() {
+                            const i = subscriptions.indexOf(inner);
+                            if (i >= 0)
+                                subscriptions.splice(i, 1);
+                            completeIfDone();
+                        },
+                    });
+                    subscriptions.push(inner);
+                },
+                error(e) { observer.error(e); },
+                complete() { completeIfDone(); },
+            });
+            function completeIfDone() {
+                if (outer.closed && subscriptions.length === 0) {
+                    observer.complete();
+                }
+            }
+            return () => {
+                subscriptions.forEach(s => s.unsubscribe());
+                outer.unsubscribe();
+            };
+        });
+    }
+    [(SymbolObservable)]() { return this; }
+    static from(x) {
+        const C = (typeof this === "function" ? this : Observable);
+        if (x == null) {
+            throw new TypeError(x + " is not an object");
+        }
+        const observableMethod = getMethod(x, SymbolObservable);
+        if (observableMethod) {
+            const observable = observableMethod.call(x);
+            if (Object(observable) !== observable) {
+                throw new TypeError(observable + " is not an object");
+            }
+            if (isObservable(observable) && observable.constructor === C) {
+                return observable;
+            }
+            return new C(observer => observable.subscribe(observer));
+        }
+        if (hasSymbol("iterator")) {
+            const iteratorMethod = getMethod(x, SymbolIterator);
+            if (iteratorMethod) {
+                return new C(observer => {
+                    enqueue(() => {
+                        if (observer.closed)
+                            return;
+                        for (const item of iteratorMethod.call(x)) {
+                            observer.next(item);
+                            if (observer.closed)
+                                return;
+                        }
+                        observer.complete();
+                    });
+                });
+            }
+        }
+        if (Array.isArray(x)) {
+            return new C(observer => {
+                enqueue(() => {
+                    if (observer.closed)
+                        return;
+                    for (const item of x) {
+                        observer.next(item);
+                        if (observer.closed)
+                            return;
+                    }
+                    observer.complete();
+                });
+            });
+        }
+        throw new TypeError(x + " is not observable");
+    }
+    static of(...items) {
+        const C = (typeof this === "function" ? this : Observable);
+        return new C(observer => {
+            enqueue(() => {
+                if (observer.closed)
+                    return;
+                for (const item of items) {
+                    observer.next(item);
+                    if (observer.closed)
+                        return;
+                }
+                observer.complete();
+            });
+        });
+    }
+    static get [SymbolSpecies]() { return this; }
+}
+if (hasSymbols()) {
+    Object.defineProperty(Observable, Symbol("extensions"), {
+        value: {
+            symbol: SymbolObservable,
+            hostReportError,
+        },
+        configurable: true,
+    });
+}
+
+/**
+ * Unsubscribe from a subscription returned by something that looks like an observable,
+ * but is not necessarily our observable implementation.
+ */
+function unsubscribe(subscription) {
+    if (typeof subscription === "function") {
+        subscription();
+    }
+    else if (subscription && typeof subscription.unsubscribe === "function") {
+        subscription.unsubscribe();
+    }
+}
+
+// TODO: This observer iteration approach looks inelegant and expensive
+// Idea: Come up with super class for Subscription that contains the
+//       notify*, ... methods and use it here
+/**
+ * A subject is a "hot" observable (see `multicast`) that has its observer
+ * methods (`.next(value)`, `.error(error)`, `.complete()`) exposed.
+ *
+ * Be careful, though! With great power comes great responsibility. Only use
+ * the `Subject` when you really need to trigger updates "from the outside" and
+ * try to keep the code that can access it to a minimum. Return
+ * `Observable.from(mySubject)` to not allow other code to mutate.
+ */
+class MulticastSubject extends Observable {
+    constructor() {
+        super(observer => {
+            this._observers.add(observer);
+            return () => this._observers.delete(observer);
+        });
+        this._observers = new Set();
+    }
+    next(value) {
+        for (const observer of this._observers) {
+            observer.next(value);
+        }
+    }
+    error(error) {
+        for (const observer of this._observers) {
+            observer.error(error);
+        }
+    }
+    complete() {
+        for (const observer of this._observers) {
+            observer.complete();
+        }
+    }
+}
+
+// TODO: Subject already creates additional observables "under the hood",
+//       now we introduce even more. A true native MulticastObservable
+//       would be preferable.
+/**
+ * Takes a "cold" observable and returns a wrapping "hot" observable that
+ * proxies the input observable's values and errors.
+ *
+ * An observable is called "cold" when its initialization function is run
+ * for each new subscriber. This is how observable-fns's `Observable`
+ * implementation works.
+ *
+ * A hot observable is an observable where new subscribers subscribe to
+ * the upcoming values of an already-initialiazed observable.
+ *
+ * The multicast observable will lazily subscribe to the source observable
+ * once it has its first own subscriber and will unsubscribe from the
+ * source observable when its last own subscriber unsubscribed.
+ */
+function multicast(coldObservable) {
+    const subject = new MulticastSubject();
+    let sourceSubscription;
+    let subscriberCount = 0;
+    return new Observable(observer => {
+        // Init source subscription lazily
+        if (!sourceSubscription) {
+            sourceSubscription = coldObservable.subscribe(subject);
+        }
+        // Pipe all events from `subject` into this observable
+        const subscription = subject.subscribe(observer);
+        subscriberCount++;
+        return () => {
+            subscriberCount--;
+            subscription.unsubscribe();
+            // Close source subscription once last subscriber has unsubscribed
+            if (subscriberCount === 0) {
+                unsubscribe(sourceSubscription);
+                sourceSubscription = undefined;
+            }
+        };
+    });
+}
+
+// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
+function allSettled(values) {
+    return Promise.all(values.map(item => {
+        const onFulfill = (value) => {
+            return { status: 'fulfilled', value };
+        };
+        const onReject = (reason) => {
+            return { status: 'rejected', reason };
+        };
+        const itemPromise = Promise.resolve(item);
+        try {
+            return itemPromise.then(onFulfill, onReject);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }));
+}
+
+/** Pool event type. Specifies the type of each `PoolEvent`. */
+var PoolEventType;
+(function (PoolEventType) {
+    PoolEventType["initialized"] = "initialized";
+    PoolEventType["taskCanceled"] = "taskCanceled";
+    PoolEventType["taskCompleted"] = "taskCompleted";
+    PoolEventType["taskFailed"] = "taskFailed";
+    PoolEventType["taskQueued"] = "taskQueued";
+    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
+    PoolEventType["taskStart"] = "taskStart";
+    PoolEventType["terminated"] = "terminated";
+})(PoolEventType || (PoolEventType = {}));
+
+const $errors = Symbol("thread.errors");
+const $events = Symbol("thread.events");
+const $terminate = Symbol("thread.terminate");
+const $transferable = Symbol("thread.transferable");
+const $worker = Symbol("thread.worker");
+
+function fail$1(message) {
+    throw Error(message);
+}
+/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
+const Thread = {
+    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
+    errors(thread) {
+        return thread[$errors] || fail$1("Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
+    events(thread) {
+        return thread[$events] || fail$1("Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
+    },
+    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
+    terminate(thread) {
+        return thread[$terminate]();
+    }
+};
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+let nextPoolID = 1;
+function createArray(size) {
+    const array = [];
+    for (let index = 0; index < size; index++) {
+        array.push(index);
+    }
+    return array;
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function flatMap(array, mapper) {
+    return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
+}
+function slugify(text) {
+    return text.replace(/\W/g, " ").trim().replace(/\s+/g, "-");
+}
+function spawnWorkers(spawnWorker, count) {
+    return createArray(count).map(() => ({
+        init: spawnWorker(),
+        runningTasks: []
+    }));
+}
+class WorkerPool {
+    constructor(spawnWorker, optionsOrSize) {
+        this.eventSubject = new MulticastSubject();
+        this.initErrors = [];
+        this.isClosing = false;
+        this.nextTaskID = 1;
+        this.taskQueue = [];
+        const options = typeof optionsOrSize === "number"
+            ? { size: optionsOrSize }
+            : optionsOrSize || {};
+        const { size = defaultPoolSize } = options;
+        this.debug = browser(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
+        this.options = options;
+        this.workers = spawnWorkers(spawnWorker, size);
+        this.eventObservable = multicast(Observable.from(this.eventSubject));
+        Promise.all(this.workers.map(worker => worker.init)).then(() => this.eventSubject.next({
+            type: PoolEventType.initialized,
+            size: this.workers.length
+        }), error => {
+            this.debug("Error while initializing pool worker:", error);
+            this.eventSubject.error(error);
+            this.initErrors.push(error);
+        });
+    }
+    findIdlingWorker() {
+        const { concurrency = 1 } = this.options;
+        return this.workers.find(worker => worker.runningTasks.length < concurrency);
+    }
+    runPoolTask(worker, task) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const workerID = this.workers.indexOf(worker) + 1;
+            this.debug(`Running task #${task.id} on worker #${workerID}...`);
+            this.eventSubject.next({
+                type: PoolEventType.taskStart,
+                taskID: task.id,
+                workerID
+            });
+            try {
+                const returnValue = yield task.run(yield worker.init);
+                this.debug(`Task #${task.id} completed successfully`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCompleted,
+                    returnValue,
+                    taskID: task.id,
+                    workerID
+                });
+            }
+            catch (error) {
+                this.debug(`Task #${task.id} failed`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskFailed,
+                    taskID: task.id,
+                    error,
+                    workerID
+                });
+            }
+        });
+    }
+    run(worker, task) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const runPromise = (() => __awaiter$1(this, void 0, void 0, function* () {
+                const removeTaskFromWorkersRunningTasks = () => {
+                    worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
+                };
+                // Defer task execution by one tick to give handlers time to subscribe
+                yield delay(0);
+                try {
+                    yield this.runPoolTask(worker, task);
+                }
+                finally {
+                    removeTaskFromWorkersRunningTasks();
+                    if (!this.isClosing) {
+                        this.scheduleWork();
+                    }
+                }
+            }))();
+            worker.runningTasks.push(runPromise);
+        });
+    }
+    scheduleWork() {
+        this.debug(`Attempt de-queueing a task in order to run it...`);
+        const availableWorker = this.findIdlingWorker();
+        if (!availableWorker)
+            return;
+        const nextTask = this.taskQueue.shift();
+        if (!nextTask) {
+            this.debug(`Task queue is empty`);
+            this.eventSubject.next({ type: PoolEventType.taskQueueDrained });
+            return;
+        }
+        this.run(availableWorker, nextTask);
+    }
+    taskCompletion(taskID) {
+        return new Promise((resolve, reject) => {
+            const eventSubscription = this.events().subscribe(event => {
+                if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    resolve(event.returnValue);
+                }
+                else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    reject(event.error);
+                }
+                else if (event.type === PoolEventType.terminated) {
+                    eventSubscription.unsubscribe();
+                    reject(Error("Pool has been terminated before task was run."));
+                }
+            });
+        });
+    }
+    settled(allowResolvingImmediately = false) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
+            const taskFailures = [];
+            const failureSubscription = this.eventObservable.subscribe(event => {
+                if (event.type === PoolEventType.taskFailed) {
+                    taskFailures.push(event.error);
+                }
+            });
+            if (this.initErrors.length > 0) {
+                return Promise.reject(this.initErrors[0]);
+            }
+            if (allowResolvingImmediately && this.taskQueue.length === 0) {
+                yield allSettled(getCurrentlyRunningTasks());
+                return taskFailures;
+            }
+            yield new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained) {
+                            subscription.unsubscribe();
+                            resolve(void 0);
+                        }
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            yield allSettled(getCurrentlyRunningTasks());
+            failureSubscription.unsubscribe();
+            return taskFailures;
+        });
+    }
+    completed(allowResolvingImmediately = false) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const settlementPromise = this.settled(allowResolvingImmediately);
+            const earlyExitPromise = new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained) {
+                            subscription.unsubscribe();
+                            resolve(settlementPromise);
+                        }
+                        else if (event.type === PoolEventType.taskFailed) {
+                            subscription.unsubscribe();
+                            reject(event.error);
+                        }
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            const errors = yield Promise.race([
+                settlementPromise,
+                earlyExitPromise
+            ]);
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+        });
+    }
+    events() {
+        return this.eventObservable;
+    }
+    queue(taskFunction) {
+        const { maxQueuedJobs = Infinity } = this.options;
+        if (this.isClosing) {
+            throw Error(`Cannot schedule pool tasks after terminate() has been called.`);
+        }
+        if (this.initErrors.length > 0) {
+            throw this.initErrors[0];
+        }
+        const taskID = this.nextTaskID++;
+        const taskCompletion = this.taskCompletion(taskID);
+        taskCompletion.catch((error) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
+        const task = {
+            id: taskID,
+            run: taskFunction,
+            cancel: () => {
+                if (this.taskQueue.indexOf(task) === -1)
+                    return;
+                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCanceled,
+                    taskID: task.id
+                });
+            },
+            then: taskCompletion.then.bind(taskCompletion)
+        };
+        if (this.taskQueue.length >= maxQueuedJobs) {
+            throw Error("Maximum number of pool tasks queued. Refusing to queue another one.\n" +
+                "This usually happens for one of two reasons: We are either at peak " +
+                "workload right now or some tasks just won't finish, thus blocking the pool.");
+        }
+        this.debug(`Queueing task #${task.id}...`);
+        this.taskQueue.push(task);
+        this.eventSubject.next({
+            type: PoolEventType.taskQueued,
+            taskID: task.id
+        });
+        this.scheduleWork();
+        return task;
+    }
+    terminate(force) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            this.isClosing = true;
+            if (!force) {
+                yield this.completed(true);
+            }
+            this.eventSubject.next({
+                type: PoolEventType.terminated,
+                remainingQueue: [...this.taskQueue]
+            });
+            this.eventSubject.complete();
+            yield Promise.all(this.workers.map((worker) => __awaiter$1(this, void 0, void 0, function* () { return Thread.terminate(yield worker.init); })));
+        });
+    }
+}
+WorkerPool.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+function PoolConstructor(spawnWorker, optionsOrSize) {
+    // The function exists only so we don't need to use `new` to create a pool (we still can, though).
+    // If the Pool is a class or not is an implementation detail that should not concern the user.
+    return new WorkerPool(spawnWorker, optionsOrSize);
+}
+PoolConstructor.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+const Pool = PoolConstructor;
+
+const doNothing$1 = () => undefined;
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+function createPromiseWithResolver() {
+    let alreadyResolved = false;
+    let resolvedTo;
+    let resolver = doNothing$1;
+    const promise = new Promise(resolve => {
+        if (alreadyResolved) {
+            resolve(resolvedTo);
+        }
+        else {
+            resolver = resolve;
+        }
+    });
+    const exposedResolver = (value) => {
+        alreadyResolved = true;
+        resolvedTo = value;
+        resolver(resolvedTo);
+    };
+    return [promise, exposedResolver];
+}
+
+/// <reference lib="dom" />
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (WorkerEventType = {}));
+
+const doNothing = () => undefined;
+const returnInput = (input) => input;
+const runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+    throw error;
+}
+function isThenable(thing) {
+    return thing && typeof thing.then === "function";
+}
+/**
+ * Creates a hybrid, combining the APIs of an Observable and a Promise.
+ *
+ * It is used to proxy async process states when we are initially not sure
+ * if that async process will yield values once (-> Promise) or multiple
+ * times (-> Observable).
+ *
+ * Note that the observable promise inherits some of the observable's characteristics:
+ * The `init` function will be called *once for every time anyone subscribes to it*.
+ *
+ * If this is undesired, derive a hot observable from it using `makeHot()` and
+ * subscribe to that.
+ */
+class ObservablePromise extends Observable {
+    constructor(init) {
+        super((originalObserver) => {
+            // tslint:disable-next-line no-this-assignment
+            const self = this;
+            const observer = Object.assign(Object.assign({}, originalObserver), { complete() {
+                    originalObserver.complete();
+                    self.onCompletion();
+                }, error(error) {
+                    originalObserver.error(error);
+                    self.onError(error);
+                },
+                next(value) {
+                    originalObserver.next(value);
+                    self.onNext(value);
+                } });
+            try {
+                this.initHasRun = true;
+                return init(observer);
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+        this.initHasRun = false;
+        this.fulfillmentCallbacks = [];
+        this.rejectionCallbacks = [];
+        this.firstValueSet = false;
+        this.state = "pending";
+    }
+    onNext(value) {
+        if (!this.firstValueSet) {
+            this.firstValue = value;
+            this.firstValueSet = true;
+        }
+    }
+    onError(error) {
+        this.state = "rejected";
+        this.rejection = error;
+        for (const onRejected of this.rejectionCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onRejected(error));
+        }
+    }
+    onCompletion() {
+        this.state = "fulfilled";
+        for (const onFulfilled of this.fulfillmentCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onFulfilled(this.firstValue));
+        }
+    }
+    then(onFulfilledRaw, onRejectedRaw) {
+        const onFulfilled = onFulfilledRaw || returnInput;
+        const onRejected = onRejectedRaw || fail;
+        let onRejectedCalled = false;
+        return new Promise((resolve, reject) => {
+            const rejectionCallback = (error) => {
+                if (onRejectedCalled)
+                    return;
+                onRejectedCalled = true;
+                try {
+                    resolve(onRejected(error));
+                }
+                catch (anotherError) {
+                    reject(anotherError);
+                }
+            };
+            const fulfillmentCallback = (value) => {
+                try {
+                    resolve(onFulfilled(value));
+                }
+                catch (error) {
+                    rejectionCallback(error);
+                }
+            };
+            if (!this.initHasRun) {
+                this.subscribe({ error: rejectionCallback });
+            }
+            if (this.state === "fulfilled") {
+                return resolve(onFulfilled(this.firstValue));
+            }
+            if (this.state === "rejected") {
+                onRejectedCalled = true;
+                return resolve(onRejected(this.rejection));
+            }
+            this.fulfillmentCallbacks.push(fulfillmentCallback);
+            this.rejectionCallbacks.push(rejectionCallback);
+        });
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onCompleted) {
+        const handler = onCompleted || doNothing;
+        return this.then((value) => {
+            handler();
+            return value;
+        }, () => handler());
+    }
+    static from(thing) {
+        if (isThenable(thing)) {
+            return new ObservablePromise(observer => {
+                const onFulfilled = (value) => {
+                    observer.next(value);
+                    observer.complete();
+                };
+                const onRejected = (error) => {
+                    observer.error(error);
+                };
+                thing.then(onFulfilled, onRejected);
+            });
+        }
+        else {
+            return super.from(thing);
+        }
+    }
+}
+
+function isTransferable$1(thing) {
+    if (!thing || typeof thing !== "object")
+        return false;
+    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
+    return true;
+}
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === "object" && thing[$transferable];
+}
+function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable$1(payload))
+            throw Error();
+        transferables = [payload];
+    }
+    return {
+        [$transferable]: true,
+        send: payload,
+        transferables
+    };
+}
+
+/////////////////////////////
+// Messages sent by master:
+var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (MasterMessageType = {}));
+////////////////////////////
+// Messages sent by worker:
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (WorkerMessageType = {}));
+
+/*
+ * This source file contains the code for proxying calls in the master thread to calls in the workers
+ * by `.postMessage()`-ing.
+ *
+ * Keep in mind that this code can make or break the program's performance! Need to optimize more…
+ */
+const debugMessages$1 = browser("threads:master:messages");
+let nextJobUID = 1;
+const dedupe = (array) => Array.from(new Set(array));
+const isJobErrorMessage = (data) => data && data.type === WorkerMessageType.error;
+const isJobResultMessage = (data) => data && data.type === WorkerMessageType.result;
+const isJobStartMessage = (data) => data && data.type === WorkerMessageType.running;
+function createObservableForJob(worker, jobUID) {
+    return new Observable(observer => {
+        let asyncType;
+        const messageHandler = ((event) => {
+            debugMessages$1("Message from worker:", event.data);
+            if (!event.data || event.data.uid !== jobUID)
+                return;
+            if (isJobStartMessage(event.data)) {
+                asyncType = event.data.resultType;
+            }
+            else if (isJobResultMessage(event.data)) {
+                if (asyncType === "promise") {
+                    if (typeof event.data.payload !== "undefined") {
+                        observer.next(deserialize(event.data.payload));
+                    }
+                    observer.complete();
+                    worker.removeEventListener("message", messageHandler);
+                }
+                else {
+                    if (event.data.payload) {
+                        observer.next(deserialize(event.data.payload));
+                    }
+                    if (event.data.complete) {
+                        observer.complete();
+                        worker.removeEventListener("message", messageHandler);
+                    }
+                }
+            }
+            else if (isJobErrorMessage(event.data)) {
+                const error = deserialize(event.data.error);
+                if (asyncType === "promise" || !asyncType) {
+                    observer.error(error);
+                }
+                else {
+                    observer.error(error);
+                }
+                worker.removeEventListener("message", messageHandler);
+            }
+        });
+        worker.addEventListener("message", messageHandler);
+        return () => {
+            if (asyncType === "observable" || !asyncType) {
+                const cancelMessage = {
+                    type: MasterMessageType.cancel,
+                    uid: jobUID
+                };
+                worker.postMessage(cancelMessage);
+            }
+            worker.removeEventListener("message", messageHandler);
+        };
+    });
+}
+function prepareArguments(rawArgs) {
+    if (rawArgs.length === 0) {
+        // Exit early if possible
+        return {
+            args: [],
+            transferables: []
+        };
+    }
+    const args = [];
+    const transferables = [];
+    for (const arg of rawArgs) {
+        if (isTransferDescriptor(arg)) {
+            args.push(serialize(arg.send));
+            transferables.push(...arg.transferables);
+        }
+        else {
+            args.push(serialize(arg));
+        }
+    }
+    return {
+        args,
+        transferables: transferables.length === 0 ? transferables : dedupe(transferables)
+    };
+}
+function createProxyFunction(worker, method) {
+    return ((...rawArgs) => {
+        const uid = nextJobUID++;
+        const { args, transferables } = prepareArguments(rawArgs);
+        const runMessage = {
+            type: MasterMessageType.run,
+            uid,
+            method,
+            args
+        };
+        debugMessages$1("Sending command to run function to worker:", runMessage);
+        try {
+            worker.postMessage(runMessage, transferables);
+        }
+        catch (error) {
+            return ObservablePromise.from(Promise.reject(error));
+        }
+        return ObservablePromise.from(multicast(createObservableForJob(worker, uid)));
+    });
+}
+function createProxyModule(worker, methodNames) {
+    const proxy = {};
+    for (const methodName of methodNames) {
+        proxy[methodName] = createProxyFunction(worker, methodName);
+    }
+    return proxy;
+}
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const debugMessages = browser("threads:master:messages");
+const debugSpawn = browser("threads:master:spawn");
+const debugThreadUtils = browser("threads:master:thread-utils");
+const isInitMessage = (data) => data && data.type === "init";
+const isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
+const initMessageTimeout = typeof process !== "undefined" && process.env.THREADS_WORKER_INIT_TIMEOUT
+    ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10)
+    : 10000;
+function withTimeout(promise, timeoutInMs, errorMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let timeoutHandle;
+        const timeout = new Promise((resolve, reject) => {
+            timeoutHandle = setTimeout(() => reject(Error(errorMessage)), timeoutInMs);
+        });
+        const result = yield Promise.race([
+            promise,
+            timeout
+        ]);
+        clearTimeout(timeoutHandle);
+        return result;
+    });
+}
+function receiveInitMessage(worker) {
+    return new Promise((resolve, reject) => {
+        const messageHandler = ((event) => {
+            debugMessages("Message from worker before finishing initialization:", event.data);
+            if (isInitMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                resolve(event.data);
+            }
+            else if (isUncaughtErrorMessage(event.data)) {
+                worker.removeEventListener("message", messageHandler);
+                reject(deserialize(event.data.error));
+            }
+        });
+        worker.addEventListener("message", messageHandler);
+    });
+}
+function createEventObservable(worker, workerTermination) {
+    return new Observable(observer => {
+        const messageHandler = ((messageEvent) => {
+            const workerEvent = {
+                type: WorkerEventType.message,
+                data: messageEvent.data
+            };
+            observer.next(workerEvent);
+        });
+        const rejectionHandler = ((errorEvent) => {
+            debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
+            const workerEvent = {
+                type: WorkerEventType.internalError,
+                error: Error(errorEvent.reason)
+            };
+            observer.next(workerEvent);
+        });
+        worker.addEventListener("message", messageHandler);
+        worker.addEventListener("unhandledrejection", rejectionHandler);
+        workerTermination.then(() => {
+            const terminationEvent = {
+                type: WorkerEventType.termination
+            };
+            worker.removeEventListener("message", messageHandler);
+            worker.removeEventListener("unhandledrejection", rejectionHandler);
+            observer.next(terminationEvent);
+            observer.complete();
+        });
+    });
+}
+function createTerminator(worker) {
+    const [termination, resolver] = createPromiseWithResolver();
+    const terminate = () => __awaiter(this, void 0, void 0, function* () {
+        debugThreadUtils("Terminating worker");
+        // Newer versions of worker_threads workers return a promise
+        yield worker.terminate();
+        resolver();
+    });
+    return { terminate, termination };
+}
+function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
+    const workerErrors = workerEvents
+        .filter(event => event.type === WorkerEventType.internalError)
+        .map(errorEvent => errorEvent.error);
+    // tslint:disable-next-line prefer-object-spread
+    return Object.assign(raw, {
+        [$errors]: workerErrors,
+        [$events]: workerEvents,
+        [$terminate]: terminate,
+        [$worker]: worker
+    });
+}
+/**
+ * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
+ * abstraction layer to provide the transparent API and verifies that
+ * the worker has initialized successfully.
+ *
+ * @param worker Instance of `Worker`. Either a web worker, `worker_threads` worker or `tiny-worker` worker.
+ * @param [options]
+ * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
+ */
+function spawn(worker, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        debugSpawn("Initializing new thread");
+        const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
+        const initMessage = yield withTimeout(receiveInitMessage(worker), timeout, `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`);
+        const exposed = initMessage.exposed;
+        const { termination, terminate } = createTerminator(worker);
+        const events = createEventObservable(worker, termination);
+        if (exposed.type === "function") {
+            const proxy = createProxyFunction(worker);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else if (exposed.type === "module") {
+            const proxy = createProxyModule(worker, exposed.methods);
+            return setPrivateThreadProps(proxy, worker, events, terminate);
+        }
+        else {
+            const type = exposed.type;
+            throw Error(`Worker init message states unexpected type of expose(): ${type}`);
+        }
+    });
+}
+
+/** Separate class to spawn workers from source code blobs or strings. */
+const BlobWorker = getWorkerImplementation().blob;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+getWorkerImplementation().default;
+
+var TerminateController = /** @class */ (function () {
+    function TerminateController() {
+        this.threads = [];
+        this.pools = [];
+    }
+    TerminateController.prototype.addThread = function (thread) {
+        this.threads.push(thread);
+    };
+    TerminateController.prototype.addPool = function (pool) {
+        this.pools.push(pool);
+    };
+    TerminateController.prototype.terminate = function (force) {
+        if (force === void 0) { force = false; }
+        return __awaiter$2(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(__spreadArray(__spreadArray([], this.threads.map(function (t) { return Thread.terminate(t); })), this.pools.map(function (p) { return p.terminate(force); })))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return TerminateController;
+}());
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getGlobal() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    else if (typeof self !== 'undefined') {
+        return self;
+    }
+    else if (typeof window !== 'undefined') {
+        return window;
+    }
+    else if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+}
+var globalThis$1 = getGlobal();
+
+function instanceOf(obj, className) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var Type = globalThis$1[className];
+    return Type != null && obj instanceof Type;
+}
+function isTransferable(obj) {
+    return (instanceOf(obj, 'ArrayBuffer') ||
+        instanceOf(obj, 'MessagePort') ||
+        instanceOf(obj, 'ImageBitmap') ||
+        instanceOf(obj, 'OffscreenCanvas'));
+}
+function isTypedArray(obj) {
+    return (instanceOf(obj, 'Int8Array') ||
+        instanceOf(obj, 'Uint8Array') ||
+        instanceOf(obj, 'Uint8ClampedArray') ||
+        instanceOf(obj, 'Int16Array') ||
+        instanceOf(obj, 'Uint16Array') ||
+        instanceOf(obj, 'Int32Array') ||
+        instanceOf(obj, 'Uint32Array') ||
+        instanceOf(obj, 'Float32Array') ||
+        instanceOf(obj, 'Float64Array') ||
+        instanceOf(obj, 'BigInt64Array') ||
+        instanceOf(obj, 'BigUint64Array'));
+}
+/**
+ * A function that will recursively inspect an object and return a Threads
+ * `Transfer` that contains all the `Transferable`s in the given object.
+ *
+ * @param obj The object to make transferable.
+ * @returns A `Transfer` from Threads.
+ */
+function makeTransferable(obj) {
+    if (isTransferable(obj)) {
+        return Transfer(obj);
+    }
+    else if (obj != null && typeof obj === 'object') {
+        var transferables = findTransferables(obj);
+        return Transfer(obj, transferables);
+    }
+    else {
+        return obj;
+    }
+}
+function findTransferables(obj) {
+    if (isTransferable(obj)) {
+        return [obj];
+    }
+    else if (typeof obj === 'object') {
+        if (Array.isArray(obj)) {
+            var result_1 = [];
+            obj.forEach(function (o) { return result_1.push.apply(result_1, findTransferables(o)); });
+            return result_1;
+        }
+        else if (isTypedArray(obj)) {
+            return [obj.buffer];
+        }
+        else if (obj != null) {
+            return Object.values(obj).reduce(function (acc, value) {
+                acc.push.apply(acc, findTransferables(value));
+                return acc;
+            }, []);
+        }
+        else {
+            return [];
+        }
+    }
+    else {
+        return [];
+    }
+}
+
+const workerName = "png-decoder-worker.js";
+const workerText = `!function(){"use strict";
+/*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */function t(t,e,n,i){return new(n||(n=Promise))((function(r,a){function s(t){try{l(i.next(t))}catch(t){a(t)}}function o(t){try{l(i.throw(t))}catch(t){a(t)}}function l(t){var e;t.done?r(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(s,o)}l((i=i.apply(t,e||[])).next())}))}function e(t,e){var n,i,r,a,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return a={next:o(0),throw:o(1),return:o(2)},"function"==typeof Symbol&&(a[Symbol.iterator]=function(){return this}),a;function o(a){return function(o){return function(a){if(n)throw new TypeError("Generator is already executing.");for(;s;)try{if(n=1,i&&(r=2&a[0]?i.return:a[0]?i.throw||((r=i.return)&&r.call(i),0):i.next)&&!(r=r.call(i,a[1])).done)return r;switch(i=0,r&&(a=[2&a[0],r.value]),a[0]){case 0:case 1:r=a;break;case 4:return s.label++,{value:a[1],done:!1};case 5:s.label++,i=a[1],a=[0];continue;case 7:a=s.ops.pop(),s.trys.pop();continue;default:if(!(r=s.trys,(r=r.length>0&&r[r.length-1])||6!==a[0]&&2!==a[0])){s=0;continue}if(3===a[0]&&(!r||a[1]>r[0]&&a[1]<r[3])){s.label=a[1];break}if(6===a[0]&&s.label<r[1]){s.label=r[1],r=a;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(a);break}r[2]&&s.ops.pop(),s.trys.pop();continue}a=e.call(t,s)}catch(t){a=[6,t],i=0}finally{n=r=0}if(5&a[0])throw a[1];return{value:a[0]?a[1]:void 0,done:!0}}([a,o])}}}const n={deserialize:t=>Object.assign(Error(t.message),{name:t.name,stack:t.stack}),serialize:t=>({__error_marker:"$$error",message:t.message,name:t.name,stack:t.stack})};let i={deserialize(t){return(e=t)&&"object"==typeof e&&"__error_marker"in e&&"$$error"===e.__error_marker?n.deserialize(t):t;var e},serialize:t=>t instanceof Error?n.serialize(t):t};function r(t){return i.deserialize(t)}function a(t){return i.serialize(t)}const s=Symbol("thread.transferable");function o(t,e){if(!e){if(!(n=t)||"object"!=typeof n)throw Error();e=[t]}var n;return{[s]:!0,send:t,transferables:e}}var l,h;!function(t){t.cancel="cancel",t.run="run"}(l||(l={})),function(t){t.error="error",t.init="init",t.result="result",t.running="running",t.uncaughtError="uncaughtError"}(h||(h={}));var d=function(){const t="undefined"!=typeof self&&"undefined"!=typeof Window&&self instanceof Window;return!("undefined"==typeof self||!self.postMessage||t)},f=function(t,e){self.postMessage(t,e)},c=function(t){const e=e=>{t(e.data)};return self.addEventListener("message",e),()=>{self.removeEventListener("message",e)}},u=function(t,e,n,i){return new(n||(n=Promise))((function(r,a){function s(t){try{l(i.next(t))}catch(t){a(t)}}function o(t){try{l(i.throw(t))}catch(t){a(t)}}function l(t){var e;t.done?r(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(s,o)}l((i=i.apply(t,e||[])).next())}))};let _=!1;const p=new Map,w=t=>t&&t.type===l.run,b=t=>{return!!(e=t)&&("symbol"==typeof Symbol.observable&&"function"==typeof e[Symbol.observable]?e===e[Symbol.observable]():"function"==typeof e["@@observable"]&&e===e["@@observable"]())||function(t){return t&&"object"==typeof t&&"function"==typeof t.subscribe}(t);var e};function g(t){return function(t){return t&&"object"==typeof t&&t[s]}(t)?{payload:t.send,transferables:t.transferables}:{payload:t,transferables:void 0}}function m(t,e){const{payload:n,transferables:i}=g(e),r={type:h.error,uid:t,error:a(n)};f(r,i)}function y(t,e,n){const{payload:i,transferables:r}=g(n),a={type:h.result,uid:t,complete:!!e||void 0,payload:i};f(a,r)}function k(t){try{const e={type:h.uncaughtError,error:a(t)};f(e)}catch(e){console.error("Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.Latest error:",e,"Original error:",t)}}function v(t,e,n){return u(this,void 0,void 0,(function*(){let i;try{i=e(...n)}catch(e){return m(t,e)}const r=b(i)?"observable":"promise";if(function(t,e){const n={type:h.running,uid:t,resultType:e};f(n)}(t,r),b(i)){const e=i.subscribe((e=>y(t,!1,a(e))),(e=>{m(t,a(e)),p.delete(t)}),(()=>{y(t,!0),p.delete(t)}));p.set(t,e)}else try{const e=yield i;y(t,!0,a(e))}catch(e){m(t,a(e))}}))}function E(t){if(!d())throw Error("expose() called in the master thread.");if(_)throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");if(_=!0,"function"==typeof t)c((e=>{w(e)&&!e.method&&v(e.uid,t,e.args.map(r))})),function(){const t={type:h.init,exposed:{type:"function"}};f(t)}();else{if("object"!=typeof t||!t)throw Error(\`Invalid argument passed to expose(). Expected a function or an object, got: \${t}\`);c((e=>{w(e)&&e.method&&v(e.uid,t[e.method],e.args.map(r))}));!function(t){const e={type:h.init,exposed:{type:"module",methods:t}};f(e)}(Object.keys(t).filter((e=>"function"==typeof t[e])))}c((t=>{if((e=t)&&e.type===l.cancel){const e=t.uid,n=p.get(e);n&&(n.unsubscribe(),p.delete(e))}var e}))}"undefined"!=typeof self&&"function"==typeof self.addEventListener&&d()&&(self.addEventListener("error",(t=>{setTimeout((()=>k(t.error||t)),250)})),self.addEventListener("unhandledrejection",(t=>{const e=t.reason;e&&"string"==typeof e.message&&setTimeout((()=>k(e)),250)}))),"undefined"!=typeof process&&"function"==typeof process.on&&d()&&(process.on("uncaughtException",(t=>{setTimeout((()=>k(t)),250)})),process.on("unhandledRejection",(t=>{t&&"string"==typeof t.message&&setTimeout((()=>k(t)),250)})));var A=function(){if("undefined"!=typeof globalThis)return globalThis;if("undefined"!=typeof self)return self;if("undefined"!=typeof window)return window;if("undefined"!=typeof global)return global;throw new Error("unable to locate global object")}();function x(t,e){var n=A[e];return null!=n&&t instanceof n}function U(t){return x(t,"ArrayBuffer")||x(t,"MessagePort")||x(t,"ImageBitmap")||x(t,"OffscreenCanvas")}function z(t){return U(t)?o(t):null!=t&&"object"==typeof t?o(t,R(t)):t}function R(t){if(U(t))return[t];if("object"==typeof t){if(Array.isArray(t)){var e=[];return t.forEach((function(t){return e.push.apply(e,R(t))})),e}return function(t){return x(t,"Int8Array")||x(t,"Uint8Array")||x(t,"Uint8ClampedArray")||x(t,"Int16Array")||x(t,"Uint16Array")||x(t,"Int32Array")||x(t,"Uint32Array")||x(t,"Float32Array")||x(t,"Float64Array")||x(t,"BigInt64Array")||x(t,"BigUint64Array")}(t)?[t.buffer]:null!=t?Object.values(t).reduce((function(t,e){return t.push.apply(t,R(e)),t}),[]):[]}return[]}!function(t){if(t.TextEncoder&&t.TextDecoder)return!1;function e(t="utf-8"){if("utf-8"!==t)throw new RangeError(\`Failed to construct 'TextEncoder': The encoding label provided ('\${t}') is invalid.\`)}function n(t="utf-8",e={fatal:!1}){if("utf-8"!==t)throw new RangeError(\`Failed to construct 'TextDecoder': The encoding label provided ('\${t}') is invalid.\`);if(e.fatal)throw new Error("Failed to construct 'TextDecoder': the 'fatal' option is unsupported.")}Object.defineProperty(e.prototype,"encoding",{value:"utf-8"}),e.prototype.encode=function(t,e={stream:!1}){if(e.stream)throw new Error("Failed to encode: the 'stream' option is unsupported.");let n=0;const i=t.length;let r=0,a=Math.max(32,i+(i>>1)+7),s=new Uint8Array(a>>3<<3);for(;n<i;){let e=t.charCodeAt(n++);if(e>=55296&&e<=56319){if(n<i){const i=t.charCodeAt(n);56320==(64512&i)&&(++n,e=((1023&e)<<10)+(1023&i)+65536)}if(e>=55296&&e<=56319)continue}if(r+4>s.length){a+=8,a*=1+n/t.length*2,a=a>>3<<3;const e=new Uint8Array(a);e.set(s),s=e}if(0!=(4294967168&e)){if(0==(4294965248&e))s[r++]=e>>6&31|192;else if(0==(4294901760&e))s[r++]=e>>12&15|224,s[r++]=e>>6&63|128;else{if(0!=(4292870144&e))continue;s[r++]=e>>18&7|240,s[r++]=e>>12&63|128,s[r++]=e>>6&63|128}s[r++]=63&e|128}else s[r++]=e}return s.slice(0,r)},Object.defineProperty(n.prototype,"encoding",{value:"utf-8"}),Object.defineProperty(n.prototype,"fatal",{value:!1}),Object.defineProperty(n.prototype,"ignoreBOM",{value:!1}),n.prototype.decode=function(t,e={stream:!1}){if(e.stream)throw new Error("Failed to decode: the 'stream' option is unsupported.");const n=new Uint8Array(t);let i=0;const r=n.length,a=[];for(;i<r;){const t=n[i++];if(0===t)break;if(0==(128&t))a.push(t);else if(192==(224&t)){const e=63&n[i++];a.push((31&t)<<6|e)}else if(224==(240&t)){const e=63&n[i++],r=63&n[i++];a.push((31&t)<<12|e<<6|r)}else if(240==(248&t)){let e=(7&t)<<18|(63&n[i++])<<12|(63&n[i++])<<6|63&n[i++];e>65535&&(e-=65536,a.push(e>>>10&1023|55296),e=56320|1023&e),a.push(e)}}return String.fromCharCode.apply(null,a)},t.TextEncoder=e,t.TextDecoder=n}("undefined"!=typeof window?window:"undefined"!=typeof self?self:void 0);const L=new TextDecoder("utf-8");const T=new TextEncoder;class N{constructor(t=8192,e={}){let n=!1;"number"==typeof t?t=new ArrayBuffer(t):(n=!0,this.lastWrittenByte=t.byteLength);const i=e.offset?e.offset>>>0:0,r=t.byteLength-i;let a=i;(ArrayBuffer.isView(t)||t instanceof N)&&(t.byteLength!==t.buffer.byteLength&&(a=t.byteOffset+i),t=t.buffer),this.lastWrittenByte=n?r:0,this.buffer=t,this.length=r,this.byteLength=r,this.byteOffset=a,this.offset=0,this.littleEndian=!0,this._data=new DataView(this.buffer,a,r),this._mark=0,this._marks=[]}available(t=1){return this.offset+t<=this.length}isLittleEndian(){return this.littleEndian}setLittleEndian(){return this.littleEndian=!0,this}isBigEndian(){return!this.littleEndian}setBigEndian(){return this.littleEndian=!1,this}skip(t=1){return this.offset+=t,this}seek(t){return this.offset=t,this}mark(){return this._mark=this.offset,this}reset(){return this.offset=this._mark,this}pushMark(){return this._marks.push(this.offset),this}popMark(){const t=this._marks.pop();if(void 0===t)throw new Error("Mark stack empty");return this.seek(t),this}rewind(){return this.offset=0,this}ensureAvailable(t=1){if(!this.available(t)){const e=2*(this.offset+t),n=new Uint8Array(e);n.set(new Uint8Array(this.buffer)),this.buffer=n.buffer,this.length=this.byteLength=e,this._data=new DataView(this.buffer)}return this}readBoolean(){return 0!==this.readUint8()}readInt8(){return this._data.getInt8(this.offset++)}readUint8(){return this._data.getUint8(this.offset++)}readByte(){return this.readUint8()}readBytes(t=1){const e=new Uint8Array(t);for(let n=0;n<t;n++)e[n]=this.readByte();return e}readInt16(){const t=this._data.getInt16(this.offset,this.littleEndian);return this.offset+=2,t}readUint16(){const t=this._data.getUint16(this.offset,this.littleEndian);return this.offset+=2,t}readInt32(){const t=this._data.getInt32(this.offset,this.littleEndian);return this.offset+=4,t}readUint32(){const t=this._data.getUint32(this.offset,this.littleEndian);return this.offset+=4,t}readFloat32(){const t=this._data.getFloat32(this.offset,this.littleEndian);return this.offset+=4,t}readFloat64(){const t=this._data.getFloat64(this.offset,this.littleEndian);return this.offset+=8,t}readChar(){return String.fromCharCode(this.readInt8())}readChars(t=1){let e="";for(let n=0;n<t;n++)e+=this.readChar();return e}readUtf8(t=1){return e=this.readBytes(t),L.decode(e);var e}writeBoolean(t){return this.writeUint8(t?255:0),this}writeInt8(t){return this.ensureAvailable(1),this._data.setInt8(this.offset++,t),this._updateLastWrittenByte(),this}writeUint8(t){return this.ensureAvailable(1),this._data.setUint8(this.offset++,t),this._updateLastWrittenByte(),this}writeByte(t){return this.writeUint8(t)}writeBytes(t){this.ensureAvailable(t.length);for(let e=0;e<t.length;e++)this._data.setUint8(this.offset++,t[e]);return this._updateLastWrittenByte(),this}writeInt16(t){return this.ensureAvailable(2),this._data.setInt16(this.offset,t,this.littleEndian),this.offset+=2,this._updateLastWrittenByte(),this}writeUint16(t){return this.ensureAvailable(2),this._data.setUint16(this.offset,t,this.littleEndian),this.offset+=2,this._updateLastWrittenByte(),this}writeInt32(t){return this.ensureAvailable(4),this._data.setInt32(this.offset,t,this.littleEndian),this.offset+=4,this._updateLastWrittenByte(),this}writeUint32(t){return this.ensureAvailable(4),this._data.setUint32(this.offset,t,this.littleEndian),this.offset+=4,this._updateLastWrittenByte(),this}writeFloat32(t){return this.ensureAvailable(4),this._data.setFloat32(this.offset,t,this.littleEndian),this.offset+=4,this._updateLastWrittenByte(),this}writeFloat64(t){return this.ensureAvailable(8),this._data.setFloat64(this.offset,t,this.littleEndian),this.offset+=8,this._updateLastWrittenByte(),this}writeChar(t){return this.writeUint8(t.charCodeAt(0))}writeChars(t){for(let e=0;e<t.length;e++)this.writeUint8(t.charCodeAt(e));return this}writeUtf8(t){return this.writeBytes(function(t){return T.encode(t)}(t))}toArray(){return new Uint8Array(this.buffer,this.byteOffset,this.lastWrittenByte)}_updateLastWrittenByte(){this.offset>this.lastWrittenByte&&(this.lastWrittenByte=this.offset)}}
+/*! pako 2.0.4 https://github.com/nodeca/pako @license (MIT AND Zlib) */function O(t){let e=t.length;for(;--e>=0;)t[e]=0}const S=256,C=286,D=30,I=15,B=new Uint8Array([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]),Z=new Uint8Array([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]),F=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),M=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),P=new Array(576);O(P);const H=new Array(60);O(H);const j=new Array(512);O(j);const W=new Array(256);O(W);const K=new Array(29);O(K);const $=new Array(D);function Y(t,e,n,i,r){this.static_tree=t,this.extra_bits=e,this.extra_base=n,this.elems=i,this.max_length=r,this.has_stree=t&&t.length}let G,X,V;function q(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}O($);const J=t=>t<256?j[t]:j[256+(t>>>7)],Q=(t,e)=>{t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},tt=(t,e,n)=>{t.bi_valid>16-n?(t.bi_buf|=e<<t.bi_valid&65535,Q(t,t.bi_buf),t.bi_buf=e>>16-t.bi_valid,t.bi_valid+=n-16):(t.bi_buf|=e<<t.bi_valid&65535,t.bi_valid+=n)},et=(t,e,n)=>{tt(t,n[2*e],n[2*e+1])},nt=(t,e)=>{let n=0;do{n|=1&t,t>>>=1,n<<=1}while(--e>0);return n>>>1},it=(t,e,n)=>{const i=new Array(16);let r,a,s=0;for(r=1;r<=I;r++)i[r]=s=s+n[r-1]<<1;for(a=0;a<=e;a++){let e=t[2*a+1];0!==e&&(t[2*a]=nt(i[e]++,e))}},rt=t=>{let e;for(e=0;e<C;e++)t.dyn_ltree[2*e]=0;for(e=0;e<D;e++)t.dyn_dtree[2*e]=0;for(e=0;e<19;e++)t.bl_tree[2*e]=0;t.dyn_ltree[512]=1,t.opt_len=t.static_len=0,t.last_lit=t.matches=0},at=t=>{t.bi_valid>8?Q(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},st=(t,e,n,i)=>{const r=2*e,a=2*n;return t[r]<t[a]||t[r]===t[a]&&i[e]<=i[n]},ot=(t,e,n)=>{const i=t.heap[n];let r=n<<1;for(;r<=t.heap_len&&(r<t.heap_len&&st(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!st(e,i,t.heap[r],t.depth));)t.heap[n]=t.heap[r],n=r,r<<=1;t.heap[n]=i},lt=(t,e,n)=>{let i,r,a,s,o=0;if(0!==t.last_lit)do{i=t.pending_buf[t.d_buf+2*o]<<8|t.pending_buf[t.d_buf+2*o+1],r=t.pending_buf[t.l_buf+o],o++,0===i?et(t,r,e):(a=W[r],et(t,a+S+1,e),s=B[a],0!==s&&(r-=K[a],tt(t,r,s)),i--,a=J(i),et(t,a,n),s=Z[a],0!==s&&(i-=$[a],tt(t,i,s)))}while(o<t.last_lit);et(t,256,e)},ht=(t,e)=>{const n=e.dyn_tree,i=e.stat_desc.static_tree,r=e.stat_desc.has_stree,a=e.stat_desc.elems;let s,o,l,h=-1;for(t.heap_len=0,t.heap_max=573,s=0;s<a;s++)0!==n[2*s]?(t.heap[++t.heap_len]=h=s,t.depth[s]=0):n[2*s+1]=0;for(;t.heap_len<2;)l=t.heap[++t.heap_len]=h<2?++h:0,n[2*l]=1,t.depth[l]=0,t.opt_len--,r&&(t.static_len-=i[2*l+1]);for(e.max_code=h,s=t.heap_len>>1;s>=1;s--)ot(t,n,s);l=a;do{s=t.heap[1],t.heap[1]=t.heap[t.heap_len--],ot(t,n,1),o=t.heap[1],t.heap[--t.heap_max]=s,t.heap[--t.heap_max]=o,n[2*l]=n[2*s]+n[2*o],t.depth[l]=(t.depth[s]>=t.depth[o]?t.depth[s]:t.depth[o])+1,n[2*s+1]=n[2*o+1]=l,t.heap[1]=l++,ot(t,n,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],((t,e)=>{const n=e.dyn_tree,i=e.max_code,r=e.stat_desc.static_tree,a=e.stat_desc.has_stree,s=e.stat_desc.extra_bits,o=e.stat_desc.extra_base,l=e.stat_desc.max_length;let h,d,f,c,u,_,p=0;for(c=0;c<=I;c++)t.bl_count[c]=0;for(n[2*t.heap[t.heap_max]+1]=0,h=t.heap_max+1;h<573;h++)d=t.heap[h],c=n[2*n[2*d+1]+1]+1,c>l&&(c=l,p++),n[2*d+1]=c,d>i||(t.bl_count[c]++,u=0,d>=o&&(u=s[d-o]),_=n[2*d],t.opt_len+=_*(c+u),a&&(t.static_len+=_*(r[2*d+1]+u)));if(0!==p){do{for(c=l-1;0===t.bl_count[c];)c--;t.bl_count[c]--,t.bl_count[c+1]+=2,t.bl_count[l]--,p-=2}while(p>0);for(c=l;0!==c;c--)for(d=t.bl_count[c];0!==d;)f=t.heap[--h],f>i||(n[2*f+1]!==c&&(t.opt_len+=(c-n[2*f+1])*n[2*f],n[2*f+1]=c),d--)}})(t,e),it(n,h,t.bl_count)},dt=(t,e,n)=>{let i,r,a=-1,s=e[1],o=0,l=7,h=4;for(0===s&&(l=138,h=3),e[2*(n+1)+1]=65535,i=0;i<=n;i++)r=s,s=e[2*(i+1)+1],++o<l&&r===s||(o<h?t.bl_tree[2*r]+=o:0!==r?(r!==a&&t.bl_tree[2*r]++,t.bl_tree[32]++):o<=10?t.bl_tree[34]++:t.bl_tree[36]++,o=0,a=r,0===s?(l=138,h=3):r===s?(l=6,h=3):(l=7,h=4))},ft=(t,e,n)=>{let i,r,a=-1,s=e[1],o=0,l=7,h=4;for(0===s&&(l=138,h=3),i=0;i<=n;i++)if(r=s,s=e[2*(i+1)+1],!(++o<l&&r===s)){if(o<h)do{et(t,r,t.bl_tree)}while(0!=--o);else 0!==r?(r!==a&&(et(t,r,t.bl_tree),o--),et(t,16,t.bl_tree),tt(t,o-3,2)):o<=10?(et(t,17,t.bl_tree),tt(t,o-3,3)):(et(t,18,t.bl_tree),tt(t,o-11,7));o=0,a=r,0===s?(l=138,h=3):r===s?(l=6,h=3):(l=7,h=4)}};let ct=!1;const ut=(t,e,n,i)=>{tt(t,0+(i?1:0),3),((t,e,n,i)=>{at(t),i&&(Q(t,n),Q(t,~n)),t.pending_buf.set(t.window.subarray(e,e+n),t.pending),t.pending+=n})(t,e,n,!0)};var _t=(t,e,n,i)=>{let r,a,s=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=(t=>{let e,n=4093624447;for(e=0;e<=31;e++,n>>>=1)if(1&n&&0!==t.dyn_ltree[2*e])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(e=32;e<S;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0})(t)),ht(t,t.l_desc),ht(t,t.d_desc),s=(t=>{let e;for(dt(t,t.dyn_ltree,t.l_desc.max_code),dt(t,t.dyn_dtree,t.d_desc.max_code),ht(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*M[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e})(t),r=t.opt_len+3+7>>>3,a=t.static_len+3+7>>>3,a<=r&&(r=a)):r=a=n+5,n+4<=r&&-1!==e?ut(t,e,n,i):4===t.strategy||a===r?(tt(t,2+(i?1:0),3),lt(t,P,H)):(tt(t,4+(i?1:0),3),((t,e,n,i)=>{let r;for(tt(t,e-257,5),tt(t,n-1,5),tt(t,i-4,4),r=0;r<i;r++)tt(t,t.bl_tree[2*M[r]+1],3);ft(t,t.dyn_ltree,e-1),ft(t,t.dyn_dtree,n-1)})(t,t.l_desc.max_code+1,t.d_desc.max_code+1,s+1),lt(t,t.dyn_ltree,t.dyn_dtree)),rt(t),i&&at(t)},pt={_tr_init:t=>{ct||((()=>{let t,e,n,i,r;const a=new Array(16);for(n=0,i=0;i<28;i++)for(K[i]=n,t=0;t<1<<B[i];t++)W[n++]=i;for(W[n-1]=i,r=0,i=0;i<16;i++)for($[i]=r,t=0;t<1<<Z[i];t++)j[r++]=i;for(r>>=7;i<D;i++)for($[i]=r<<7,t=0;t<1<<Z[i]-7;t++)j[256+r++]=i;for(e=0;e<=I;e++)a[e]=0;for(t=0;t<=143;)P[2*t+1]=8,t++,a[8]++;for(;t<=255;)P[2*t+1]=9,t++,a[9]++;for(;t<=279;)P[2*t+1]=7,t++,a[7]++;for(;t<=287;)P[2*t+1]=8,t++,a[8]++;for(it(P,287,a),t=0;t<D;t++)H[2*t+1]=5,H[2*t]=nt(t,5);G=new Y(P,B,257,C,I),X=new Y(H,Z,0,D,I),V=new Y(new Array(0),F,0,19,7)})(),ct=!0),t.l_desc=new q(t.dyn_ltree,G),t.d_desc=new q(t.dyn_dtree,X),t.bl_desc=new q(t.bl_tree,V),t.bi_buf=0,t.bi_valid=0,rt(t)},_tr_stored_block:ut,_tr_flush_block:_t,_tr_tally:(t,e,n)=>(t.pending_buf[t.d_buf+2*t.last_lit]=e>>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&e,t.pending_buf[t.l_buf+t.last_lit]=255&n,t.last_lit++,0===e?t.dyn_ltree[2*n]++:(t.matches++,e--,t.dyn_ltree[2*(W[n]+S+1)]++,t.dyn_dtree[2*J(e)]++),t.last_lit===t.lit_bufsize-1),_tr_align:t=>{tt(t,2,3),et(t,256,P),(t=>{16===t.bi_valid?(Q(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)})(t)}};var wt=(t,e,n,i)=>{let r=65535&t|0,a=t>>>16&65535|0,s=0;for(;0!==n;){s=n>2e3?2e3:n,n-=s;do{r=r+e[i++]|0,a=a+r|0}while(--s);r%=65521,a%=65521}return r|a<<16|0};const bt=new Uint32Array((()=>{let t,e=[];for(var n=0;n<256;n++){t=n;for(var i=0;i<8;i++)t=1&t?3988292384^t>>>1:t>>>1;e[n]=t}return e})());var gt=(t,e,n,i)=>{const r=bt,a=i+n;t^=-1;for(let n=i;n<a;n++)t=t>>>8^r[255&(t^e[n])];return-1^t},mt={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"},yt={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8};const{_tr_init:kt,_tr_stored_block:vt,_tr_flush_block:Et,_tr_tally:At,_tr_align:xt}=pt,{Z_NO_FLUSH:Ut,Z_PARTIAL_FLUSH:zt,Z_FULL_FLUSH:Rt,Z_FINISH:Lt,Z_BLOCK:Tt,Z_OK:Nt,Z_STREAM_END:Ot,Z_STREAM_ERROR:St,Z_DATA_ERROR:Ct,Z_BUF_ERROR:Dt,Z_DEFAULT_COMPRESSION:It,Z_FILTERED:Bt,Z_HUFFMAN_ONLY:Zt,Z_RLE:Ft,Z_FIXED:Mt,Z_DEFAULT_STRATEGY:Pt,Z_UNKNOWN:Ht,Z_DEFLATED:jt}=yt,Wt=258,Kt=262,$t=103,Yt=113,Gt=666,Xt=(t,e)=>(t.msg=mt[e],e),Vt=t=>(t<<1)-(t>4?9:0),qt=t=>{let e=t.length;for(;--e>=0;)t[e]=0};let Jt=(t,e,n)=>(e<<t.hash_shift^n)&t.hash_mask;const Qt=t=>{const e=t.state;let n=e.pending;n>t.avail_out&&(n=t.avail_out),0!==n&&(t.output.set(e.pending_buf.subarray(e.pending_out,e.pending_out+n),t.next_out),t.next_out+=n,e.pending_out+=n,t.total_out+=n,t.avail_out-=n,e.pending-=n,0===e.pending&&(e.pending_out=0))},te=(t,e)=>{Et(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,Qt(t.strm)},ee=(t,e)=>{t.pending_buf[t.pending++]=e},ne=(t,e)=>{t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},ie=(t,e,n,i)=>{let r=t.avail_in;return r>i&&(r=i),0===r?0:(t.avail_in-=r,e.set(t.input.subarray(t.next_in,t.next_in+r),n),1===t.state.wrap?t.adler=wt(t.adler,e,r,n):2===t.state.wrap&&(t.adler=gt(t.adler,e,r,n)),t.next_in+=r,t.total_in+=r,r)},re=(t,e)=>{let n,i,r=t.max_chain_length,a=t.strstart,s=t.prev_length,o=t.nice_match;const l=t.strstart>t.w_size-Kt?t.strstart-(t.w_size-Kt):0,h=t.window,d=t.w_mask,f=t.prev,c=t.strstart+Wt;let u=h[a+s-1],_=h[a+s];t.prev_length>=t.good_match&&(r>>=2),o>t.lookahead&&(o=t.lookahead);do{if(n=e,h[n+s]===_&&h[n+s-1]===u&&h[n]===h[a]&&h[++n]===h[a+1]){a+=2,n++;do{}while(h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&h[++a]===h[++n]&&a<c);if(i=Wt-(c-a),a=c-Wt,i>s){if(t.match_start=e,s=i,i>=o)break;u=h[a+s-1],_=h[a+s]}}}while((e=f[e&d])>l&&0!=--r);return s<=t.lookahead?s:t.lookahead},ae=t=>{const e=t.w_size;let n,i,r,a,s;do{if(a=t.window_size-t.lookahead-t.strstart,t.strstart>=e+(e-Kt)){t.window.set(t.window.subarray(e,e+e),0),t.match_start-=e,t.strstart-=e,t.block_start-=e,i=t.hash_size,n=i;do{r=t.head[--n],t.head[n]=r>=e?r-e:0}while(--i);i=e,n=i;do{r=t.prev[--n],t.prev[n]=r>=e?r-e:0}while(--i);a+=e}if(0===t.strm.avail_in)break;if(i=ie(t.strm,t.window,t.strstart+t.lookahead,a),t.lookahead+=i,t.lookahead+t.insert>=3)for(s=t.strstart-t.insert,t.ins_h=t.window[s],t.ins_h=Jt(t,t.ins_h,t.window[s+1]);t.insert&&(t.ins_h=Jt(t,t.ins_h,t.window[s+3-1]),t.prev[s&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=s,s++,t.insert--,!(t.lookahead+t.insert<3)););}while(t.lookahead<Kt&&0!==t.strm.avail_in)},se=(t,e)=>{let n,i;for(;;){if(t.lookahead<Kt){if(ae(t),t.lookahead<Kt&&e===Ut)return 1;if(0===t.lookahead)break}if(n=0,t.lookahead>=3&&(t.ins_h=Jt(t,t.ins_h,t.window[t.strstart+3-1]),n=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),0!==n&&t.strstart-n<=t.w_size-Kt&&(t.match_length=re(t,n)),t.match_length>=3)if(i=At(t,t.strstart-t.match_start,t.match_length-3),t.lookahead-=t.match_length,t.match_length<=t.max_lazy_match&&t.lookahead>=3){t.match_length--;do{t.strstart++,t.ins_h=Jt(t,t.ins_h,t.window[t.strstart+3-1]),n=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart}while(0!=--t.match_length);t.strstart++}else t.strstart+=t.match_length,t.match_length=0,t.ins_h=t.window[t.strstart],t.ins_h=Jt(t,t.ins_h,t.window[t.strstart+1]);else i=At(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(i&&(te(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===Lt?(te(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(te(t,!1),0===t.strm.avail_out)?1:2},oe=(t,e)=>{let n,i,r;for(;;){if(t.lookahead<Kt){if(ae(t),t.lookahead<Kt&&e===Ut)return 1;if(0===t.lookahead)break}if(n=0,t.lookahead>=3&&(t.ins_h=Jt(t,t.ins_h,t.window[t.strstart+3-1]),n=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),t.prev_length=t.match_length,t.prev_match=t.match_start,t.match_length=2,0!==n&&t.prev_length<t.max_lazy_match&&t.strstart-n<=t.w_size-Kt&&(t.match_length=re(t,n),t.match_length<=5&&(t.strategy===Bt||3===t.match_length&&t.strstart-t.match_start>4096)&&(t.match_length=2)),t.prev_length>=3&&t.match_length<=t.prev_length){r=t.strstart+t.lookahead-3,i=At(t,t.strstart-1-t.prev_match,t.prev_length-3),t.lookahead-=t.prev_length-1,t.prev_length-=2;do{++t.strstart<=r&&(t.ins_h=Jt(t,t.ins_h,t.window[t.strstart+3-1]),n=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart)}while(0!=--t.prev_length);if(t.match_available=0,t.match_length=2,t.strstart++,i&&(te(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if(i=At(t,0,t.window[t.strstart-1]),i&&te(t,!1),t.strstart++,t.lookahead--,0===t.strm.avail_out)return 1}else t.match_available=1,t.strstart++,t.lookahead--}return t.match_available&&(i=At(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===Lt?(te(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(te(t,!1),0===t.strm.avail_out)?1:2};function le(t,e,n,i,r){this.good_length=t,this.max_lazy=e,this.nice_length=n,this.max_chain=i,this.func=r}const he=[new le(0,0,0,0,((t,e)=>{let n=65535;for(n>t.pending_buf_size-5&&(n=t.pending_buf_size-5);;){if(t.lookahead<=1){if(ae(t),0===t.lookahead&&e===Ut)return 1;if(0===t.lookahead)break}t.strstart+=t.lookahead,t.lookahead=0;const i=t.block_start+n;if((0===t.strstart||t.strstart>=i)&&(t.lookahead=t.strstart-i,t.strstart=i,te(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-Kt&&(te(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===Lt?(te(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(te(t,!1),t.strm.avail_out),1)})),new le(4,4,8,4,se),new le(4,5,16,8,se),new le(4,6,32,32,se),new le(4,4,16,16,oe),new le(8,16,32,32,oe),new le(8,16,128,128,oe),new le(8,32,128,256,oe),new le(32,128,258,1024,oe),new le(32,258,258,4096,oe)];function de(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=jt,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new Uint16Array(1146),this.dyn_dtree=new Uint16Array(122),this.bl_tree=new Uint16Array(78),qt(this.dyn_ltree),qt(this.dyn_dtree),qt(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new Uint16Array(16),this.heap=new Uint16Array(573),qt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),qt(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}const fe=t=>{if(!t||!t.state)return Xt(t,St);t.total_in=t.total_out=0,t.data_type=Ht;const e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:Yt,t.adler=2===e.wrap?0:1,e.last_flush=Ut,kt(e),Nt},ce=t=>{const e=fe(t);var n;return e===Nt&&((n=t.state).window_size=2*n.w_size,qt(n.head),n.max_lazy_match=he[n.level].max_lazy,n.good_match=he[n.level].good_length,n.nice_match=he[n.level].nice_length,n.max_chain_length=he[n.level].max_chain,n.strstart=0,n.block_start=0,n.lookahead=0,n.insert=0,n.match_length=n.prev_length=2,n.match_available=0,n.ins_h=0),e},ue=(t,e,n,i,r,a)=>{if(!t)return St;let s=1;if(e===It&&(e=6),i<0?(s=0,i=-i):i>15&&(s=2,i-=16),r<1||r>9||n!==jt||i<8||i>15||e<0||e>9||a<0||a>Mt)return Xt(t,St);8===i&&(i=9);const o=new de;return t.state=o,o.strm=t,o.wrap=s,o.gzhead=null,o.w_bits=i,o.w_size=1<<o.w_bits,o.w_mask=o.w_size-1,o.hash_bits=r+7,o.hash_size=1<<o.hash_bits,o.hash_mask=o.hash_size-1,o.hash_shift=~~((o.hash_bits+3-1)/3),o.window=new Uint8Array(2*o.w_size),o.head=new Uint16Array(o.hash_size),o.prev=new Uint16Array(o.w_size),o.lit_bufsize=1<<r+6,o.pending_buf_size=4*o.lit_bufsize,o.pending_buf=new Uint8Array(o.pending_buf_size),o.d_buf=1*o.lit_bufsize,o.l_buf=3*o.lit_bufsize,o.level=e,o.strategy=a,o.method=n,ce(t)};var _e={deflateInit:(t,e)=>ue(t,e,jt,15,8,Pt),deflateInit2:ue,deflateReset:ce,deflateResetKeep:fe,deflateSetHeader:(t,e)=>t&&t.state?2!==t.state.wrap?St:(t.state.gzhead=e,Nt):St,deflate:(t,e)=>{let n,i;if(!t||!t.state||e>Tt||e<0)return t?Xt(t,St):St;const r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===Gt&&e!==Lt)return Xt(t,0===t.avail_out?Dt:St);r.strm=t;const a=r.last_flush;if(r.last_flush=e,42===r.status)if(2===r.wrap)t.adler=0,ee(r,31),ee(r,139),ee(r,8),r.gzhead?(ee(r,(r.gzhead.text?1:0)+(r.gzhead.hcrc?2:0)+(r.gzhead.extra?4:0)+(r.gzhead.name?8:0)+(r.gzhead.comment?16:0)),ee(r,255&r.gzhead.time),ee(r,r.gzhead.time>>8&255),ee(r,r.gzhead.time>>16&255),ee(r,r.gzhead.time>>24&255),ee(r,9===r.level?2:r.strategy>=Zt||r.level<2?4:0),ee(r,255&r.gzhead.os),r.gzhead.extra&&r.gzhead.extra.length&&(ee(r,255&r.gzhead.extra.length),ee(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(t.adler=gt(t.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=69):(ee(r,0),ee(r,0),ee(r,0),ee(r,0),ee(r,0),ee(r,9===r.level?2:r.strategy>=Zt||r.level<2?4:0),ee(r,3),r.status=Yt);else{let e=jt+(r.w_bits-8<<4)<<8,n=-1;n=r.strategy>=Zt||r.level<2?0:r.level<6?1:6===r.level?2:3,e|=n<<6,0!==r.strstart&&(e|=32),e+=31-e%31,r.status=Yt,ne(r,e),0!==r.strstart&&(ne(r,t.adler>>>16),ne(r,65535&t.adler)),t.adler=1}if(69===r.status)if(r.gzhead.extra){for(n=r.pending;r.gzindex<(65535&r.gzhead.extra.length)&&(r.pending!==r.pending_buf_size||(r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),Qt(t),n=r.pending,r.pending!==r.pending_buf_size));)ee(r,255&r.gzhead.extra[r.gzindex]),r.gzindex++;r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=73)}else r.status=73;if(73===r.status)if(r.gzhead.name){n=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),Qt(t),n=r.pending,r.pending===r.pending_buf_size)){i=1;break}i=r.gzindex<r.gzhead.name.length?255&r.gzhead.name.charCodeAt(r.gzindex++):0,ee(r,i)}while(0!==i);r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),0===i&&(r.gzindex=0,r.status=91)}else r.status=91;if(91===r.status)if(r.gzhead.comment){n=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),Qt(t),n=r.pending,r.pending===r.pending_buf_size)){i=1;break}i=r.gzindex<r.gzhead.comment.length?255&r.gzhead.comment.charCodeAt(r.gzindex++):0,ee(r,i)}while(0!==i);r.gzhead.hcrc&&r.pending>n&&(t.adler=gt(t.adler,r.pending_buf,r.pending-n,n)),0===i&&(r.status=$t)}else r.status=$t;if(r.status===$t&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&Qt(t),r.pending+2<=r.pending_buf_size&&(ee(r,255&t.adler),ee(r,t.adler>>8&255),t.adler=0,r.status=Yt)):r.status=Yt),0!==r.pending){if(Qt(t),0===t.avail_out)return r.last_flush=-1,Nt}else if(0===t.avail_in&&Vt(e)<=Vt(a)&&e!==Lt)return Xt(t,Dt);if(r.status===Gt&&0!==t.avail_in)return Xt(t,Dt);if(0!==t.avail_in||0!==r.lookahead||e!==Ut&&r.status!==Gt){let n=r.strategy===Zt?((t,e)=>{let n;for(;;){if(0===t.lookahead&&(ae(t),0===t.lookahead)){if(e===Ut)return 1;break}if(t.match_length=0,n=At(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,n&&(te(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===Lt?(te(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(te(t,!1),0===t.strm.avail_out)?1:2})(r,e):r.strategy===Ft?((t,e)=>{let n,i,r,a;const s=t.window;for(;;){if(t.lookahead<=Wt){if(ae(t),t.lookahead<=Wt&&e===Ut)return 1;if(0===t.lookahead)break}if(t.match_length=0,t.lookahead>=3&&t.strstart>0&&(r=t.strstart-1,i=s[r],i===s[++r]&&i===s[++r]&&i===s[++r])){a=t.strstart+Wt;do{}while(i===s[++r]&&i===s[++r]&&i===s[++r]&&i===s[++r]&&i===s[++r]&&i===s[++r]&&i===s[++r]&&i===s[++r]&&r<a);t.match_length=Wt-(a-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(n=At(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(n=At(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),n&&(te(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===Lt?(te(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(te(t,!1),0===t.strm.avail_out)?1:2})(r,e):he[r.level].func(r,e);if(3!==n&&4!==n||(r.status=Gt),1===n||3===n)return 0===t.avail_out&&(r.last_flush=-1),Nt;if(2===n&&(e===zt?xt(r):e!==Tt&&(vt(r,0,0,!1),e===Rt&&(qt(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),Qt(t),0===t.avail_out))return r.last_flush=-1,Nt}return e!==Lt?Nt:r.wrap<=0?Ot:(2===r.wrap?(ee(r,255&t.adler),ee(r,t.adler>>8&255),ee(r,t.adler>>16&255),ee(r,t.adler>>24&255),ee(r,255&t.total_in),ee(r,t.total_in>>8&255),ee(r,t.total_in>>16&255),ee(r,t.total_in>>24&255)):(ne(r,t.adler>>>16),ne(r,65535&t.adler)),Qt(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?Nt:Ot)},deflateEnd:t=>{if(!t||!t.state)return St;const e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==$t&&e!==Yt&&e!==Gt?Xt(t,St):(t.state=null,e===Yt?Xt(t,Ct):Nt)},deflateSetDictionary:(t,e)=>{let n=e.length;if(!t||!t.state)return St;const i=t.state,r=i.wrap;if(2===r||1===r&&42!==i.status||i.lookahead)return St;if(1===r&&(t.adler=wt(t.adler,e,n,0)),i.wrap=0,n>=i.w_size){0===r&&(qt(i.head),i.strstart=0,i.block_start=0,i.insert=0);let t=new Uint8Array(i.w_size);t.set(e.subarray(n-i.w_size,n),0),e=t,n=i.w_size}const a=t.avail_in,s=t.next_in,o=t.input;for(t.avail_in=n,t.next_in=0,t.input=e,ae(i);i.lookahead>=3;){let t=i.strstart,e=i.lookahead-2;do{i.ins_h=Jt(i,i.ins_h,i.window[t+3-1]),i.prev[t&i.w_mask]=i.head[i.ins_h],i.head[i.ins_h]=t,t++}while(--e);i.strstart=t,i.lookahead=2,ae(i)}return i.strstart+=i.lookahead,i.block_start=i.strstart,i.insert=i.lookahead,i.lookahead=0,i.match_length=i.prev_length=2,i.match_available=0,t.next_in=s,t.input=o,t.avail_in=a,i.wrap=r,Nt},deflateInfo:"pako deflate (from Nodeca project)"};const pe=(t,e)=>Object.prototype.hasOwnProperty.call(t,e);var we=function(t){const e=Array.prototype.slice.call(arguments,1);for(;e.length;){const n=e.shift();if(n){if("object"!=typeof n)throw new TypeError(n+"must be non-object");for(const e in n)pe(n,e)&&(t[e]=n[e])}}return t},be=t=>{let e=0;for(let n=0,i=t.length;n<i;n++)e+=t[n].length;const n=new Uint8Array(e);for(let e=0,i=0,r=t.length;e<r;e++){let r=t[e];n.set(r,i),i+=r.length}return n};let ge=!0;try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(t){ge=!1}const me=new Uint8Array(256);for(let t=0;t<256;t++)me[t]=t>=252?6:t>=248?5:t>=240?4:t>=224?3:t>=192?2:1;me[254]=me[254]=1;var ye=t=>{if("function"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);let e,n,i,r,a,s=t.length,o=0;for(r=0;r<s;r++)n=t.charCodeAt(r),55296==(64512&n)&&r+1<s&&(i=t.charCodeAt(r+1),56320==(64512&i)&&(n=65536+(n-55296<<10)+(i-56320),r++)),o+=n<128?1:n<2048?2:n<65536?3:4;for(e=new Uint8Array(o),a=0,r=0;a<o;r++)n=t.charCodeAt(r),55296==(64512&n)&&r+1<s&&(i=t.charCodeAt(r+1),56320==(64512&i)&&(n=65536+(n-55296<<10)+(i-56320),r++)),n<128?e[a++]=n:n<2048?(e[a++]=192|n>>>6,e[a++]=128|63&n):n<65536?(e[a++]=224|n>>>12,e[a++]=128|n>>>6&63,e[a++]=128|63&n):(e[a++]=240|n>>>18,e[a++]=128|n>>>12&63,e[a++]=128|n>>>6&63,e[a++]=128|63&n);return e},ke=(t,e)=>{const n=e||t.length;if("function"==typeof TextDecoder&&TextDecoder.prototype.decode)return(new TextDecoder).decode(t.subarray(0,e));let i,r;const a=new Array(2*n);for(r=0,i=0;i<n;){let e=t[i++];if(e<128){a[r++]=e;continue}let s=me[e];if(s>4)a[r++]=65533,i+=s-1;else{for(e&=2===s?31:3===s?15:7;s>1&&i<n;)e=e<<6|63&t[i++],s--;s>1?a[r++]=65533:e<65536?a[r++]=e:(e-=65536,a[r++]=55296|e>>10&1023,a[r++]=56320|1023&e)}}return((t,e)=>{if(e<65534&&t.subarray&&ge)return String.fromCharCode.apply(null,t.length===e?t:t.subarray(0,e));let n="";for(let i=0;i<e;i++)n+=String.fromCharCode(t[i]);return n})(a,r)},ve=(t,e)=>{(e=e||t.length)>t.length&&(e=t.length);let n=e-1;for(;n>=0&&128==(192&t[n]);)n--;return n<0||0===n?e:n+me[t[n]]>e?n:e};var Ee=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0};const Ae=Object.prototype.toString,{Z_NO_FLUSH:xe,Z_SYNC_FLUSH:Ue,Z_FULL_FLUSH:ze,Z_FINISH:Re,Z_OK:Le,Z_STREAM_END:Te,Z_DEFAULT_COMPRESSION:Ne,Z_DEFAULT_STRATEGY:Oe,Z_DEFLATED:Se}=yt;function Ce(t){this.options=we({level:Ne,method:Se,chunkSize:16384,windowBits:15,memLevel:8,strategy:Oe},t||{});let e=this.options;e.raw&&e.windowBits>0?e.windowBits=-e.windowBits:e.gzip&&e.windowBits>0&&e.windowBits<16&&(e.windowBits+=16),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new Ee,this.strm.avail_out=0;let n=_e.deflateInit2(this.strm,e.level,e.method,e.windowBits,e.memLevel,e.strategy);if(n!==Le)throw new Error(mt[n]);if(e.header&&_e.deflateSetHeader(this.strm,e.header),e.dictionary){let t;if(t="string"==typeof e.dictionary?ye(e.dictionary):"[object ArrayBuffer]"===Ae.call(e.dictionary)?new Uint8Array(e.dictionary):e.dictionary,n=_e.deflateSetDictionary(this.strm,t),n!==Le)throw new Error(mt[n]);this._dict_set=!0}}Ce.prototype.push=function(t,e){const n=this.strm,i=this.options.chunkSize;let r,a;if(this.ended)return!1;for(a=e===~~e?e:!0===e?Re:xe,"string"==typeof t?n.input=ye(t):"[object ArrayBuffer]"===Ae.call(t)?n.input=new Uint8Array(t):n.input=t,n.next_in=0,n.avail_in=n.input.length;;)if(0===n.avail_out&&(n.output=new Uint8Array(i),n.next_out=0,n.avail_out=i),(a===Ue||a===ze)&&n.avail_out<=6)this.onData(n.output.subarray(0,n.next_out)),n.avail_out=0;else{if(r=_e.deflate(n,a),r===Te)return n.next_out>0&&this.onData(n.output.subarray(0,n.next_out)),r=_e.deflateEnd(this.strm),this.onEnd(r),this.ended=!0,r===Le;if(0!==n.avail_out){if(a>0&&n.next_out>0)this.onData(n.output.subarray(0,n.next_out)),n.avail_out=0;else if(0===n.avail_in)break}else this.onData(n.output)}return!0},Ce.prototype.onData=function(t){this.chunks.push(t)},Ce.prototype.onEnd=function(t){t===Le&&(this.result=be(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg};var De=function(t,e){let n,i,r,a,s,o,l,h,d,f,c,u,_,p,w,b,g,m,y,k,v,E,A,x;const U=t.state;n=t.next_in,A=t.input,i=n+(t.avail_in-5),r=t.next_out,x=t.output,a=r-(e-t.avail_out),s=r+(t.avail_out-257),o=U.dmax,l=U.wsize,h=U.whave,d=U.wnext,f=U.window,c=U.hold,u=U.bits,_=U.lencode,p=U.distcode,w=(1<<U.lenbits)-1,b=(1<<U.distbits)-1;t:do{u<15&&(c+=A[n++]<<u,u+=8,c+=A[n++]<<u,u+=8),g=_[c&w];e:for(;;){if(m=g>>>24,c>>>=m,u-=m,m=g>>>16&255,0===m)x[r++]=65535&g;else{if(!(16&m)){if(0==(64&m)){g=_[(65535&g)+(c&(1<<m)-1)];continue e}if(32&m){U.mode=12;break t}t.msg="invalid literal/length code",U.mode=30;break t}y=65535&g,m&=15,m&&(u<m&&(c+=A[n++]<<u,u+=8),y+=c&(1<<m)-1,c>>>=m,u-=m),u<15&&(c+=A[n++]<<u,u+=8,c+=A[n++]<<u,u+=8),g=p[c&b];n:for(;;){if(m=g>>>24,c>>>=m,u-=m,m=g>>>16&255,!(16&m)){if(0==(64&m)){g=p[(65535&g)+(c&(1<<m)-1)];continue n}t.msg="invalid distance code",U.mode=30;break t}if(k=65535&g,m&=15,u<m&&(c+=A[n++]<<u,u+=8,u<m&&(c+=A[n++]<<u,u+=8)),k+=c&(1<<m)-1,k>o){t.msg="invalid distance too far back",U.mode=30;break t}if(c>>>=m,u-=m,m=r-a,k>m){if(m=k-m,m>h&&U.sane){t.msg="invalid distance too far back",U.mode=30;break t}if(v=0,E=f,0===d){if(v+=l-m,m<y){y-=m;do{x[r++]=f[v++]}while(--m);v=r-k,E=x}}else if(d<m){if(v+=l+d-m,m-=d,m<y){y-=m;do{x[r++]=f[v++]}while(--m);if(v=0,d<y){m=d,y-=m;do{x[r++]=f[v++]}while(--m);v=r-k,E=x}}}else if(v+=d-m,m<y){y-=m;do{x[r++]=f[v++]}while(--m);v=r-k,E=x}for(;y>2;)x[r++]=E[v++],x[r++]=E[v++],x[r++]=E[v++],y-=3;y&&(x[r++]=E[v++],y>1&&(x[r++]=E[v++]))}else{v=r-k;do{x[r++]=x[v++],x[r++]=x[v++],x[r++]=x[v++],y-=3}while(y>2);y&&(x[r++]=x[v++],y>1&&(x[r++]=x[v++]))}break}}break}}while(n<i&&r<s);y=u>>3,n-=y,u-=y<<3,c&=(1<<u)-1,t.next_in=n,t.next_out=r,t.avail_in=n<i?i-n+5:5-(n-i),t.avail_out=r<s?s-r+257:257-(r-s),U.hold=c,U.bits=u};const Ie=15,Be=new Uint16Array([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0]),Ze=new Uint8Array([16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78]),Fe=new Uint16Array([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0]),Me=new Uint8Array([16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64]);var Pe=(t,e,n,i,r,a,s,o)=>{const l=o.bits;let h,d,f,c,u,_,p=0,w=0,b=0,g=0,m=0,y=0,k=0,v=0,E=0,A=0,x=null,U=0;const z=new Uint16Array(16),R=new Uint16Array(16);let L,T,N,O=null,S=0;for(p=0;p<=Ie;p++)z[p]=0;for(w=0;w<i;w++)z[e[n+w]]++;for(m=l,g=Ie;g>=1&&0===z[g];g--);if(m>g&&(m=g),0===g)return r[a++]=20971520,r[a++]=20971520,o.bits=1,0;for(b=1;b<g&&0===z[b];b++);for(m<b&&(m=b),v=1,p=1;p<=Ie;p++)if(v<<=1,v-=z[p],v<0)return-1;if(v>0&&(0===t||1!==g))return-1;for(R[1]=0,p=1;p<Ie;p++)R[p+1]=R[p]+z[p];for(w=0;w<i;w++)0!==e[n+w]&&(s[R[e[n+w]]++]=w);if(0===t?(x=O=s,_=19):1===t?(x=Be,U-=257,O=Ze,S-=257,_=256):(x=Fe,O=Me,_=-1),A=0,w=0,p=b,u=a,y=m,k=0,f=-1,E=1<<m,c=E-1,1===t&&E>852||2===t&&E>592)return 1;for(;;){L=p-k,s[w]<_?(T=0,N=s[w]):s[w]>_?(T=O[S+s[w]],N=x[U+s[w]]):(T=96,N=0),h=1<<p-k,d=1<<y,b=d;do{d-=h,r[u+(A>>k)+d]=L<<24|T<<16|N|0}while(0!==d);for(h=1<<p-1;A&h;)h>>=1;if(0!==h?(A&=h-1,A+=h):A=0,w++,0==--z[p]){if(p===g)break;p=e[n+s[w]]}if(p>m&&(A&c)!==f){for(0===k&&(k=m),u+=b,y=p-k,v=1<<y;y+k<g&&(v-=z[y+k],!(v<=0));)y++,v<<=1;if(E+=1<<y,1===t&&E>852||2===t&&E>592)return 1;f=A&c,r[f]=m<<24|y<<16|u-a|0}}return 0!==A&&(r[u+A]=p-k<<24|64<<16|0),o.bits=m,0};const{Z_FINISH:He,Z_BLOCK:je,Z_TREES:We,Z_OK:Ke,Z_STREAM_END:$e,Z_NEED_DICT:Ye,Z_STREAM_ERROR:Ge,Z_DATA_ERROR:Xe,Z_MEM_ERROR:Ve,Z_BUF_ERROR:qe,Z_DEFLATED:Je}=yt,Qe=12,tn=30,en=t=>(t>>>24&255)+(t>>>8&65280)+((65280&t)<<8)+((255&t)<<24);function nn(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new Uint16Array(320),this.work=new Uint16Array(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}const rn=t=>{if(!t||!t.state)return Ge;const e=t.state;return t.total_in=t.total_out=e.total=0,t.msg="",e.wrap&&(t.adler=1&e.wrap),e.mode=1,e.last=0,e.havedict=0,e.dmax=32768,e.head=null,e.hold=0,e.bits=0,e.lencode=e.lendyn=new Int32Array(852),e.distcode=e.distdyn=new Int32Array(592),e.sane=1,e.back=-1,Ke},an=t=>{if(!t||!t.state)return Ge;const e=t.state;return e.wsize=0,e.whave=0,e.wnext=0,rn(t)},sn=(t,e)=>{let n;if(!t||!t.state)return Ge;const i=t.state;return e<0?(n=0,e=-e):(n=1+(e>>4),e<48&&(e&=15)),e&&(e<8||e>15)?Ge:(null!==i.window&&i.wbits!==e&&(i.window=null),i.wrap=n,i.wbits=e,an(t))},on=(t,e)=>{if(!t)return Ge;const n=new nn;t.state=n,n.window=null;const i=sn(t,e);return i!==Ke&&(t.state=null),i};let ln,hn,dn=!0;const fn=t=>{if(dn){ln=new Int32Array(512),hn=new Int32Array(32);let e=0;for(;e<144;)t.lens[e++]=8;for(;e<256;)t.lens[e++]=9;for(;e<280;)t.lens[e++]=7;for(;e<288;)t.lens[e++]=8;for(Pe(1,t.lens,0,288,ln,0,t.work,{bits:9}),e=0;e<32;)t.lens[e++]=5;Pe(2,t.lens,0,32,hn,0,t.work,{bits:5}),dn=!1}t.lencode=ln,t.lenbits=9,t.distcode=hn,t.distbits=5},cn=(t,e,n,i)=>{let r;const a=t.state;return null===a.window&&(a.wsize=1<<a.wbits,a.wnext=0,a.whave=0,a.window=new Uint8Array(a.wsize)),i>=a.wsize?(a.window.set(e.subarray(n-a.wsize,n),0),a.wnext=0,a.whave=a.wsize):(r=a.wsize-a.wnext,r>i&&(r=i),a.window.set(e.subarray(n-i,n-i+r),a.wnext),(i-=r)?(a.window.set(e.subarray(n-i,n),0),a.wnext=i,a.whave=a.wsize):(a.wnext+=r,a.wnext===a.wsize&&(a.wnext=0),a.whave<a.wsize&&(a.whave+=r))),0};var un={inflateReset:an,inflateReset2:sn,inflateResetKeep:rn,inflateInit:t=>on(t,15),inflateInit2:on,inflate:(t,e)=>{let n,i,r,a,s,o,l,h,d,f,c,u,_,p,w,b,g,m,y,k,v,E,A=0;const x=new Uint8Array(4);let U,z;const R=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]);if(!t||!t.state||!t.output||!t.input&&0!==t.avail_in)return Ge;n=t.state,n.mode===Qe&&(n.mode=13),s=t.next_out,r=t.output,l=t.avail_out,a=t.next_in,i=t.input,o=t.avail_in,h=n.hold,d=n.bits,f=o,c=l,E=Ke;t:for(;;)switch(n.mode){case 1:if(0===n.wrap){n.mode=13;break}for(;d<16;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(2&n.wrap&&35615===h){n.check=0,x[0]=255&h,x[1]=h>>>8&255,n.check=gt(n.check,x,2,0),h=0,d=0,n.mode=2;break}if(n.flags=0,n.head&&(n.head.done=!1),!(1&n.wrap)||(((255&h)<<8)+(h>>8))%31){t.msg="incorrect header check",n.mode=tn;break}if((15&h)!==Je){t.msg="unknown compression method",n.mode=tn;break}if(h>>>=4,d-=4,v=8+(15&h),0===n.wbits)n.wbits=v;else if(v>n.wbits){t.msg="invalid window size",n.mode=tn;break}n.dmax=1<<n.wbits,t.adler=n.check=1,n.mode=512&h?10:Qe,h=0,d=0;break;case 2:for(;d<16;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(n.flags=h,(255&n.flags)!==Je){t.msg="unknown compression method",n.mode=tn;break}if(57344&n.flags){t.msg="unknown header flags set",n.mode=tn;break}n.head&&(n.head.text=h>>8&1),512&n.flags&&(x[0]=255&h,x[1]=h>>>8&255,n.check=gt(n.check,x,2,0)),h=0,d=0,n.mode=3;case 3:for(;d<32;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.head&&(n.head.time=h),512&n.flags&&(x[0]=255&h,x[1]=h>>>8&255,x[2]=h>>>16&255,x[3]=h>>>24&255,n.check=gt(n.check,x,4,0)),h=0,d=0,n.mode=4;case 4:for(;d<16;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.head&&(n.head.xflags=255&h,n.head.os=h>>8),512&n.flags&&(x[0]=255&h,x[1]=h>>>8&255,n.check=gt(n.check,x,2,0)),h=0,d=0,n.mode=5;case 5:if(1024&n.flags){for(;d<16;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.length=h,n.head&&(n.head.extra_len=h),512&n.flags&&(x[0]=255&h,x[1]=h>>>8&255,n.check=gt(n.check,x,2,0)),h=0,d=0}else n.head&&(n.head.extra=null);n.mode=6;case 6:if(1024&n.flags&&(u=n.length,u>o&&(u=o),u&&(n.head&&(v=n.head.extra_len-n.length,n.head.extra||(n.head.extra=new Uint8Array(n.head.extra_len)),n.head.extra.set(i.subarray(a,a+u),v)),512&n.flags&&(n.check=gt(n.check,i,u,a)),o-=u,a+=u,n.length-=u),n.length))break t;n.length=0,n.mode=7;case 7:if(2048&n.flags){if(0===o)break t;u=0;do{v=i[a+u++],n.head&&v&&n.length<65536&&(n.head.name+=String.fromCharCode(v))}while(v&&u<o);if(512&n.flags&&(n.check=gt(n.check,i,u,a)),o-=u,a+=u,v)break t}else n.head&&(n.head.name=null);n.length=0,n.mode=8;case 8:if(4096&n.flags){if(0===o)break t;u=0;do{v=i[a+u++],n.head&&v&&n.length<65536&&(n.head.comment+=String.fromCharCode(v))}while(v&&u<o);if(512&n.flags&&(n.check=gt(n.check,i,u,a)),o-=u,a+=u,v)break t}else n.head&&(n.head.comment=null);n.mode=9;case 9:if(512&n.flags){for(;d<16;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(h!==(65535&n.check)){t.msg="header crc mismatch",n.mode=tn;break}h=0,d=0}n.head&&(n.head.hcrc=n.flags>>9&1,n.head.done=!0),t.adler=n.check=0,n.mode=Qe;break;case 10:for(;d<32;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}t.adler=n.check=en(h),h=0,d=0,n.mode=11;case 11:if(0===n.havedict)return t.next_out=s,t.avail_out=l,t.next_in=a,t.avail_in=o,n.hold=h,n.bits=d,Ye;t.adler=n.check=1,n.mode=Qe;case Qe:if(e===je||e===We)break t;case 13:if(n.last){h>>>=7&d,d-=7&d,n.mode=27;break}for(;d<3;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}switch(n.last=1&h,h>>>=1,d-=1,3&h){case 0:n.mode=14;break;case 1:if(fn(n),n.mode=20,e===We){h>>>=2,d-=2;break t}break;case 2:n.mode=17;break;case 3:t.msg="invalid block type",n.mode=tn}h>>>=2,d-=2;break;case 14:for(h>>>=7&d,d-=7&d;d<32;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if((65535&h)!=(h>>>16^65535)){t.msg="invalid stored block lengths",n.mode=tn;break}if(n.length=65535&h,h=0,d=0,n.mode=15,e===We)break t;case 15:n.mode=16;case 16:if(u=n.length,u){if(u>o&&(u=o),u>l&&(u=l),0===u)break t;r.set(i.subarray(a,a+u),s),o-=u,a+=u,l-=u,s+=u,n.length-=u;break}n.mode=Qe;break;case 17:for(;d<14;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(n.nlen=257+(31&h),h>>>=5,d-=5,n.ndist=1+(31&h),h>>>=5,d-=5,n.ncode=4+(15&h),h>>>=4,d-=4,n.nlen>286||n.ndist>30){t.msg="too many length or distance symbols",n.mode=tn;break}n.have=0,n.mode=18;case 18:for(;n.have<n.ncode;){for(;d<3;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.lens[R[n.have++]]=7&h,h>>>=3,d-=3}for(;n.have<19;)n.lens[R[n.have++]]=0;if(n.lencode=n.lendyn,n.lenbits=7,U={bits:n.lenbits},E=Pe(0,n.lens,0,19,n.lencode,0,n.work,U),n.lenbits=U.bits,E){t.msg="invalid code lengths set",n.mode=tn;break}n.have=0,n.mode=19;case 19:for(;n.have<n.nlen+n.ndist;){for(;A=n.lencode[h&(1<<n.lenbits)-1],w=A>>>24,b=A>>>16&255,g=65535&A,!(w<=d);){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(g<16)h>>>=w,d-=w,n.lens[n.have++]=g;else{if(16===g){for(z=w+2;d<z;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(h>>>=w,d-=w,0===n.have){t.msg="invalid bit length repeat",n.mode=tn;break}v=n.lens[n.have-1],u=3+(3&h),h>>>=2,d-=2}else if(17===g){for(z=w+3;d<z;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}h>>>=w,d-=w,v=0,u=3+(7&h),h>>>=3,d-=3}else{for(z=w+7;d<z;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}h>>>=w,d-=w,v=0,u=11+(127&h),h>>>=7,d-=7}if(n.have+u>n.nlen+n.ndist){t.msg="invalid bit length repeat",n.mode=tn;break}for(;u--;)n.lens[n.have++]=v}}if(n.mode===tn)break;if(0===n.lens[256]){t.msg="invalid code -- missing end-of-block",n.mode=tn;break}if(n.lenbits=9,U={bits:n.lenbits},E=Pe(1,n.lens,0,n.nlen,n.lencode,0,n.work,U),n.lenbits=U.bits,E){t.msg="invalid literal/lengths set",n.mode=tn;break}if(n.distbits=6,n.distcode=n.distdyn,U={bits:n.distbits},E=Pe(2,n.lens,n.nlen,n.ndist,n.distcode,0,n.work,U),n.distbits=U.bits,E){t.msg="invalid distances set",n.mode=tn;break}if(n.mode=20,e===We)break t;case 20:n.mode=21;case 21:if(o>=6&&l>=258){t.next_out=s,t.avail_out=l,t.next_in=a,t.avail_in=o,n.hold=h,n.bits=d,De(t,c),s=t.next_out,r=t.output,l=t.avail_out,a=t.next_in,i=t.input,o=t.avail_in,h=n.hold,d=n.bits,n.mode===Qe&&(n.back=-1);break}for(n.back=0;A=n.lencode[h&(1<<n.lenbits)-1],w=A>>>24,b=A>>>16&255,g=65535&A,!(w<=d);){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(b&&0==(240&b)){for(m=w,y=b,k=g;A=n.lencode[k+((h&(1<<m+y)-1)>>m)],w=A>>>24,b=A>>>16&255,g=65535&A,!(m+w<=d);){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}h>>>=m,d-=m,n.back+=m}if(h>>>=w,d-=w,n.back+=w,n.length=g,0===b){n.mode=26;break}if(32&b){n.back=-1,n.mode=Qe;break}if(64&b){t.msg="invalid literal/length code",n.mode=tn;break}n.extra=15&b,n.mode=22;case 22:if(n.extra){for(z=n.extra;d<z;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.length+=h&(1<<n.extra)-1,h>>>=n.extra,d-=n.extra,n.back+=n.extra}n.was=n.length,n.mode=23;case 23:for(;A=n.distcode[h&(1<<n.distbits)-1],w=A>>>24,b=A>>>16&255,g=65535&A,!(w<=d);){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(0==(240&b)){for(m=w,y=b,k=g;A=n.distcode[k+((h&(1<<m+y)-1)>>m)],w=A>>>24,b=A>>>16&255,g=65535&A,!(m+w<=d);){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}h>>>=m,d-=m,n.back+=m}if(h>>>=w,d-=w,n.back+=w,64&b){t.msg="invalid distance code",n.mode=tn;break}n.offset=g,n.extra=15&b,n.mode=24;case 24:if(n.extra){for(z=n.extra;d<z;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}n.offset+=h&(1<<n.extra)-1,h>>>=n.extra,d-=n.extra,n.back+=n.extra}if(n.offset>n.dmax){t.msg="invalid distance too far back",n.mode=tn;break}n.mode=25;case 25:if(0===l)break t;if(u=c-l,n.offset>u){if(u=n.offset-u,u>n.whave&&n.sane){t.msg="invalid distance too far back",n.mode=tn;break}u>n.wnext?(u-=n.wnext,_=n.wsize-u):_=n.wnext-u,u>n.length&&(u=n.length),p=n.window}else p=r,_=s-n.offset,u=n.length;u>l&&(u=l),l-=u,n.length-=u;do{r[s++]=p[_++]}while(--u);0===n.length&&(n.mode=21);break;case 26:if(0===l)break t;r[s++]=n.length,l--,n.mode=21;break;case 27:if(n.wrap){for(;d<32;){if(0===o)break t;o--,h|=i[a++]<<d,d+=8}if(c-=l,t.total_out+=c,n.total+=c,c&&(t.adler=n.check=n.flags?gt(n.check,r,c,s-c):wt(n.check,r,c,s-c)),c=l,(n.flags?h:en(h))!==n.check){t.msg="incorrect data check",n.mode=tn;break}h=0,d=0}n.mode=28;case 28:if(n.wrap&&n.flags){for(;d<32;){if(0===o)break t;o--,h+=i[a++]<<d,d+=8}if(h!==(4294967295&n.total)){t.msg="incorrect length check",n.mode=tn;break}h=0,d=0}n.mode=29;case 29:E=$e;break t;case tn:E=Xe;break t;case 31:return Ve;default:return Ge}return t.next_out=s,t.avail_out=l,t.next_in=a,t.avail_in=o,n.hold=h,n.bits=d,(n.wsize||c!==t.avail_out&&n.mode<tn&&(n.mode<27||e!==He))&&cn(t,t.output,t.next_out,c-t.avail_out),f-=t.avail_in,c-=t.avail_out,t.total_in+=f,t.total_out+=c,n.total+=c,n.wrap&&c&&(t.adler=n.check=n.flags?gt(n.check,r,c,t.next_out-c):wt(n.check,r,c,t.next_out-c)),t.data_type=n.bits+(n.last?64:0)+(n.mode===Qe?128:0)+(20===n.mode||15===n.mode?256:0),(0===f&&0===c||e===He)&&E===Ke&&(E=qe),E},inflateEnd:t=>{if(!t||!t.state)return Ge;let e=t.state;return e.window&&(e.window=null),t.state=null,Ke},inflateGetHeader:(t,e)=>{if(!t||!t.state)return Ge;const n=t.state;return 0==(2&n.wrap)?Ge:(n.head=e,e.done=!1,Ke)},inflateSetDictionary:(t,e)=>{const n=e.length;let i,r,a;return t&&t.state?(i=t.state,0!==i.wrap&&11!==i.mode?Ge:11===i.mode&&(r=1,r=wt(r,e,n,0),r!==i.check)?Xe:(a=cn(t,e,n,n),a?(i.mode=31,Ve):(i.havedict=1,Ke))):Ge},inflateInfo:"pako inflate (from Nodeca project)"};var _n=function(){this.text=0,this.time=0,this.xflags=0,this.os=0,this.extra=null,this.extra_len=0,this.name="",this.comment="",this.hcrc=0,this.done=!1};const pn=Object.prototype.toString,{Z_NO_FLUSH:wn,Z_FINISH:bn,Z_OK:gn,Z_STREAM_END:mn,Z_NEED_DICT:yn,Z_STREAM_ERROR:kn,Z_DATA_ERROR:vn,Z_MEM_ERROR:En}=yt;function An(t){this.options=we({chunkSize:65536,windowBits:15,to:""},t||{});const e=this.options;e.raw&&e.windowBits>=0&&e.windowBits<16&&(e.windowBits=-e.windowBits,0===e.windowBits&&(e.windowBits=-15)),!(e.windowBits>=0&&e.windowBits<16)||t&&t.windowBits||(e.windowBits+=32),e.windowBits>15&&e.windowBits<48&&0==(15&e.windowBits)&&(e.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new Ee,this.strm.avail_out=0;let n=un.inflateInit2(this.strm,e.windowBits);if(n!==gn)throw new Error(mt[n]);if(this.header=new _n,un.inflateGetHeader(this.strm,this.header),e.dictionary&&("string"==typeof e.dictionary?e.dictionary=ye(e.dictionary):"[object ArrayBuffer]"===pn.call(e.dictionary)&&(e.dictionary=new Uint8Array(e.dictionary)),e.raw&&(n=un.inflateSetDictionary(this.strm,e.dictionary),n!==gn)))throw new Error(mt[n])}function xn(t,e){const n=new An(e);if(n.push(t),n.err)throw n.msg||mt[n.err];return n.result}An.prototype.push=function(t,e){const n=this.strm,i=this.options.chunkSize,r=this.options.dictionary;let a,s,o;if(this.ended)return!1;for(s=e===~~e?e:!0===e?bn:wn,"[object ArrayBuffer]"===pn.call(t)?n.input=new Uint8Array(t):n.input=t,n.next_in=0,n.avail_in=n.input.length;;){for(0===n.avail_out&&(n.output=new Uint8Array(i),n.next_out=0,n.avail_out=i),a=un.inflate(n,s),a===yn&&r&&(a=un.inflateSetDictionary(n,r),a===gn?a=un.inflate(n,s):a===vn&&(a=yn));n.avail_in>0&&a===mn&&n.state.wrap>0&&0!==t[n.next_in];)un.inflateReset(n),a=un.inflate(n,s);switch(a){case kn:case vn:case yn:case En:return this.onEnd(a),this.ended=!0,!1}if(o=n.avail_out,n.next_out&&(0===n.avail_out||a===mn))if("string"===this.options.to){let t=ve(n.output,n.next_out),e=n.next_out-t,r=ke(n.output,t);n.next_out=e,n.avail_out=i-e,e&&n.output.set(n.output.subarray(t,t+e),0),this.onData(r)}else this.onData(n.output.length===n.next_out?n.output:n.output.subarray(0,n.next_out));if(a!==gn||0!==o){if(a===mn)return a=un.inflateEnd(this.strm),this.onEnd(a),this.ended=!0,!0;if(0===n.avail_in)break}}return!0},An.prototype.onData=function(t){this.chunks.push(t)},An.prototype.onEnd=function(t){t===gn&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=be(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg};var Un={Inflate:An,inflate:xn,inflateRaw:function(t,e){return(e=e||{}).raw=!0,xn(t,e)},ungzip:xn,constants:yt};const{Inflate:zn,inflate:Rn,inflateRaw:Ln,ungzip:Tn}=Un;var Nn=zn,On=Rn;const Sn=[137,80,78,71,13,10,26,10],Cn=[];for(let t=0;t<256;t++){let e=t;for(let t=0;t<8;t++)1&e?e=3988292384^e>>>1:e>>>=1;Cn[t]=e}const Dn=4294967295;function In(t,e){return(function(t,e,n){let i=t;for(let t=0;t<n;t++)i=Cn[255&(i^e[t])]^i>>>8;return i}(Dn,t,e)^Dn)>>>0}var Bn,Zn,Fn,Mn;!function(t){t[t.UNKNOWN=-1]="UNKNOWN",t[t.GREYSCALE=0]="GREYSCALE",t[t.TRUECOLOUR=2]="TRUECOLOUR",t[t.INDEXED_COLOUR=3]="INDEXED_COLOUR",t[t.GREYSCALE_ALPHA=4]="GREYSCALE_ALPHA",t[t.TRUECOLOUR_ALPHA=6]="TRUECOLOUR_ALPHA"}(Bn||(Bn={})),function(t){t[t.UNKNOWN=-1]="UNKNOWN",t[t.DEFLATE=0]="DEFLATE"}(Zn||(Zn={})),function(t){t[t.UNKNOWN=-1]="UNKNOWN",t[t.ADAPTIVE=0]="ADAPTIVE"}(Fn||(Fn={})),function(t){t[t.UNKNOWN=-1]="UNKNOWN",t[t.NO_INTERLACE=0]="NO_INTERLACE",t[t.ADAM7=1]="ADAM7"}(Mn||(Mn={}));const Pn=new Uint8Array(0),Hn=new Uint16Array([255]),jn=255===new Uint8Array(Hn.buffer)[0];class Wn extends N{constructor(t,e={}){super(t);const{checkCrc:n=!1}=e;this._checkCrc=n,this._inflator=new Nn,this._png={width:-1,height:-1,channels:-1,data:new Uint8Array(0),depth:1,text:{}},this._end=!1,this._hasPalette=!1,this._palette=[],this._compressionMethod=Zn.UNKNOWN,this._filterMethod=Fn.UNKNOWN,this._interlaceMethod=Mn.UNKNOWN,this._colorType=-1,this.setBigEndian()}decode(){for(this.decodeSignature();!this._end;)this.decodeChunk();return this.decodeImage(),this._png}decodeSignature(){for(let t=0;t<Sn.length;t++)if(this.readUint8()!==Sn[t])throw new Error(\`wrong PNG signature. Byte at \${t} should be \${Sn[t]}.\`)}decodeChunk(){const t=this.readUint32(),e=this.readChars(4),n=this.offset;switch(e){case"IHDR":this.decodeIHDR();break;case"PLTE":this.decodePLTE(t);break;case"IDAT":this.decodeIDAT(t);break;case"IEND":this._end=!0;break;case"tRNS":this.decodetRNS(t);break;case"iCCP":this.decodeiCCP(t);break;case"tEXt":this.decodetEXt(t);break;case"pHYs":this.decodepHYs();break;default:this.skip(t)}if(this.offset-n!==t)throw new Error(\`Length mismatch while decoding chunk \${e}\`);if(this._checkCrc){const n=this.readUint32(),i=t+4,r=In(new Uint8Array(this.buffer,this.byteOffset+this.offset-i-4,i),i);if(r!==n)throw new Error(\`CRC mismatch for chunk \${e}. Expected \${n}, found \${r}\`)}else this.skip(4)}decodeIHDR(){const t=this._png;t.width=this.readUint32(),t.height=this.readUint32(),t.depth=function(t){if(1!==t&&2!==t&&4!==t&&8!==t&&16!==t)throw new Error(\`invalid bit depth: \${t}\`);return t}(this.readUint8());const e=this.readUint8();let n;switch(this._colorType=e,e){case Bn.GREYSCALE:n=1;break;case Bn.TRUECOLOUR:n=3;break;case Bn.INDEXED_COLOUR:n=1;break;case Bn.GREYSCALE_ALPHA:n=2;break;case Bn.TRUECOLOUR_ALPHA:n=4;break;default:throw new Error(\`Unknown color type: \${e}\`)}if(this._png.channels=n,this._compressionMethod=this.readUint8(),this._compressionMethod!==Zn.DEFLATE)throw new Error(\`Unsupported compression method: \${this._compressionMethod}\`);this._filterMethod=this.readUint8(),this._interlaceMethod=this.readUint8()}decodePLTE(t){if(t%3!=0)throw new RangeError(\`PLTE field length must be a multiple of 3. Got \${t}\`);const e=t/3;this._hasPalette=!0;const n=[];this._palette=n;for(let t=0;t<e;t++)n.push([this.readUint8(),this.readUint8(),this.readUint8()])}decodeIDAT(t){this._inflator.push(new Uint8Array(this.buffer,this.offset+this.byteOffset,t)),this.skip(t)}decodetRNS(t){if(3===this._colorType){if(t>this._palette.length)throw new Error(\`tRNS chunk contains more alpha values than there are palette colors (\${t} vs \${this._palette.length})\`);let e=0;for(;e<t;e++){const t=this.readByte();this._palette[e].push(t)}for(;e<this._palette.length;e++)this._palette[e].push(255)}}decodeiCCP(t){let e,n="";for(;"\0"!==(e=this.readChar());)n+=e;const i=this.readUint8();if(i!==Zn.DEFLATE)throw new Error(\`Unsupported iCCP compression method: \${i}\`);const r=this.readBytes(t-n.length-2);this._png.iccEmbeddedProfile={name:n,profile:On(r)}}decodetEXt(t){let e,n="";for(;"\0"!==(e=this.readChar());)n+=e;this._png.text[n]=this.readChars(t-n.length-1)}decodepHYs(){const t=this.readUint32(),e=this.readUint32(),n=this.readByte();this._png.resolution={x:t,y:e,unit:n}}decodeImage(){if(this._inflator.err)throw new Error(\`Error while decompressing the data: \${this._inflator.err}\`);const t=this._inflator.result;if(this._filterMethod!==Fn.ADAPTIVE)throw new Error(\`Filter method \${this._filterMethod} not supported\`);if(this._interlaceMethod!==Mn.NO_INTERLACE)throw new Error(\`Interlace method \${this._interlaceMethod} not supported\`);this.decodeInterlaceNull(t)}decodeInterlaceNull(t){const e=this._png.height,n=this._png.channels*this._png.depth/8,i=this._png.width*n,r=new Uint8Array(this._png.height*i);let a,s,o=Pn,l=0;for(let h=0;h<e;h++){switch(a=t.subarray(l+1,l+1+i),s=r.subarray(h*i,(h+1)*i),t[l]){case 0:Kn(a,s,i);break;case 1:$n(a,s,i,n);break;case 2:Yn(a,s,o,i);break;case 3:Gn(a,s,o,i,n);break;case 4:Xn(a,s,o,i,n);break;default:throw new Error(\`Unsupported filter: \${t[l]}\`)}o=s,l+=i+1}if(this._hasPalette&&(this._png.palette=this._palette),16===this._png.depth){const t=new Uint16Array(r.buffer);if(jn)for(let e=0;e<t.length;e++)t[e]=(255&(h=t[e]))<<8|h>>8&255;this._png.data=t}else this._png.data=r;var h}}function Kn(t,e,n){for(let i=0;i<n;i++)e[i]=t[i]}function $n(t,e,n,i){let r=0;for(;r<i;r++)e[r]=t[r];for(;r<n;r++)e[r]=t[r]+e[r-i]&255}function Yn(t,e,n,i){let r=0;if(0===n.length)for(;r<i;r++)e[r]=t[r];else for(;r<i;r++)e[r]=t[r]+n[r]&255}function Gn(t,e,n,i,r){let a=0;if(0===n.length){for(;a<r;a++)e[a]=t[a];for(;a<i;a++)e[a]=t[a]+(e[a-r]>>1)&255}else{for(;a<r;a++)e[a]=t[a]+(n[a]>>1)&255;for(;a<i;a++)e[a]=t[a]+(e[a-r]+n[a]>>1)&255}}function Xn(t,e,n,i,r){let a=0;if(0===n.length){for(;a<r;a++)e[a]=t[a];for(;a<i;a++)e[a]=t[a]+e[a-r]&255}else{for(;a<r;a++)e[a]=t[a]+n[a]&255;for(;a<i;a++)e[a]=t[a]+Vn(e[a-r],n[a],n[a-r])&255}}function Vn(t,e,n){const i=t+e-n,r=Math.abs(i-t),a=Math.abs(i-e),s=Math.abs(i-n);return r<=a&&r<=s?t:a<=s?e:n}var qn;!function(t){t[t.UNKNOWN=0]="UNKNOWN",t[t.METRE=1]="METRE"}(qn||(qn={}));!function(n,i){var r=(void 0===i?{}:i).expose,a=void 0===r?E:r;function s(n){var i=this;return function(){for(var r=[],a=0;a<arguments.length;a++)r[a]=arguments[a];return t(i,void 0,void 0,(function(){return e(this,(function(t){switch(t.label){case 0:return[4,n.apply(void 0,r)];case 1:return[2,z(t.sent())]}}))}))}}if("function"==typeof n)return a(s(n));var o=Object.entries(n).reduce((function(t,e){var n=e[0],i=e[1];return t[n]=s(i),t}),{});a(o)}((async t=>{return new Wn(t,e).decode();var e}))}();
+`;
+
+function makeController() {
+  return new TerminateController();
+}
+
+function makeWorker() {
+  return BlobWorker.fromText(workerText, { name: workerName });
+}
+
+async function spawnWorker(terminate) {
+  const fn = await spawn(makeWorker());
+  if (terminate != null) {
+    terminate.addThread(fn);
+  }
+  return (...args) => {
+    return fn.apply(null, [...args.map((a) => makeTransferable(a))]);
+  };
+}
+
+function spawnPool(options) {
+  return Pool(() => spawnWorker(options.terminate), options);
+}
+
+export { makeController, makeWorker, spawnPool, spawnWorker };
+
+//# sourceMappingURL=png-decoder.js.map